[deliverable/linux.git] / include / linux / clockchips.h

/*  linux/include/linux/clockchips.h
 *
 *  This file contains the structure definitions for clockchips.
 *
 *  If you are not a clockchip, or the time of day code, you should
 *  not be including this file!
 */
#ifndef _LINUX_CLOCKCHIPS_H
#define _LINUX_CLOCKCHIPS_H

/* Clock event notification values */
enum clock_event_nofitiers {
	CLOCK_EVT_NOTIFY_ADD,
	CLOCK_EVT_NOTIFY_BROADCAST_ON,
	CLOCK_EVT_NOTIFY_BROADCAST_OFF,
	CLOCK_EVT_NOTIFY_BROADCAST_FORCE,
	CLOCK_EVT_NOTIFY_BROADCAST_ENTER,
	CLOCK_EVT_NOTIFY_BROADCAST_EXIT,
	CLOCK_EVT_NOTIFY_SUSPEND,
	CLOCK_EVT_NOTIFY_RESUME,
	CLOCK_EVT_NOTIFY_CPU_DYING,
	CLOCK_EVT_NOTIFY_CPU_DEAD,
};

#ifdef CONFIG_GENERIC_CLOCKEVENTS_BUILD

#include <linux/clocksource.h>
#include <linux/cpumask.h>
#include <linux/ktime.h>
#include <linux/notifier.h>

struct clock_event_device;
struct module;

/* Clock event mode commands for legacy ->set_mode(): OBSOLETE */
enum clock_event_mode {
	CLOCK_EVT_MODE_UNUSED = 0,
	CLOCK_EVT_MODE_SHUTDOWN,
	CLOCK_EVT_MODE_PERIODIC,
	CLOCK_EVT_MODE_ONESHOT,
	CLOCK_EVT_MODE_RESUME,
};

/*
 * Possible states of a clock event device.
 *
 * DETACHED:	Device is not used by clockevents core. Initial state or can be
 *		reached from SHUTDOWN.
 * SHUTDOWN:	Device is powered-off. Can be reached from PERIODIC or ONESHOT.
 * PERIODIC:	Device is programmed to generate events periodically. Can be
 *		reached from DETACHED or SHUTDOWN.
 * ONESHOT:	Device is programmed to generate event only once. Can be reached
 *		from DETACHED or SHUTDOWN.
 */
enum clock_event_state {
	CLOCK_EVT_STATE_DETACHED = 0,
	CLOCK_EVT_STATE_SHUTDOWN,
	CLOCK_EVT_STATE_PERIODIC,
	CLOCK_EVT_STATE_ONESHOT,
};

/*
 * Clock event features
 */
#define CLOCK_EVT_FEAT_PERIODIC		0x000001
#define CLOCK_EVT_FEAT_ONESHOT		0x000002
#define CLOCK_EVT_FEAT_KTIME		0x000004
/*
 * x86(64) specific misfeatures:
 *
 * - Clockevent source stops in C3 State and needs broadcast support.
 * - Local APIC timer is used as a dummy device.
 */
#define CLOCK_EVT_FEAT_C3STOP		0x000008
#define CLOCK_EVT_FEAT_DUMMY		0x000010

/*
 * Core shall set the interrupt affinity dynamically in broadcast mode
 */
#define CLOCK_EVT_FEAT_DYNIRQ		0x000020
#define CLOCK_EVT_FEAT_PERCPU		0x000040

/*
 * Clockevent device is based on a hrtimer for broadcast
 */
#define CLOCK_EVT_FEAT_HRTIMER		0x000080

/**
 * struct clock_event_device - clock event device descriptor
 * @event_handler:	Assigned by the framework to be called by the low
 *			level handler of the event source
 * @set_next_event:	set next event function using a clocksource delta
 * @set_next_ktime:	set next event function using a direct ktime value
 * @next_event:		local storage for the next event in oneshot mode
 * @max_delta_ns:	maximum delta value in ns
 * @min_delta_ns:	minimum delta value in ns
 * @mult:		nanosecond to cycles multiplier
 * @shift:		nanoseconds to cycles divisor (power of two)
 * @mode:		operating mode, relevant only to ->set_mode(), OBSOLETE
 * @state:		current state of the device, assigned by the core code
 * @features:		features
 * @retries:		number of forced programming retries
 * @set_mode:		legacy set mode function, only for modes <= CLOCK_EVT_MODE_RESUME.
 * @set_state_periodic:	switch state to periodic, if !set_mode
 * @set_state_oneshot:	switch state to oneshot, if !set_mode
 * @set_state_shutdown:	switch state to shutdown, if !set_mode
 * @tick_resume:	resume clkevt device, if !set_mode
 * @broadcast:		function to broadcast events
 * @min_delta_ticks:	minimum delta value in ticks stored for reconfiguration
 * @max_delta_ticks:	maximum delta value in ticks stored for reconfiguration
 * @name:		ptr to clock event name
 * @rating:		variable to rate clock event devices
 * @irq:		IRQ number (only for non CPU local devices)
 * @bound_on:		Bound on CPU
 * @cpumask:		cpumask to indicate for which CPUs this device works
 * @list:		list head for the management code
 * @owner:		module reference
 */
struct clock_event_device {
	void			(*event_handler)(struct clock_event_device *);
	int			(*set_next_event)(unsigned long evt,
						  struct clock_event_device *);
	int			(*set_next_ktime)(ktime_t expires,
						  struct clock_event_device *);
	ktime_t			next_event;
	u64			max_delta_ns;
	u64			min_delta_ns;
	u32			mult;
	u32			shift;
	enum clock_event_mode	mode;
	enum clock_event_state	state;
	unsigned int		features;
	unsigned long		retries;

	/*
	 * State transition callback(s): Only one of the two groups should be
	 * defined:
	 * - set_mode(), only for modes <= CLOCK_EVT_MODE_RESUME.
	 * - set_state_{shutdown|periodic|oneshot}(), tick_resume().
	 */
	void			(*set_mode)(enum clock_event_mode mode,
					    struct clock_event_device *);
	int			(*set_state_periodic)(struct clock_event_device *);
	int			(*set_state_oneshot)(struct clock_event_device *);
	int			(*set_state_shutdown)(struct clock_event_device *);
	int			(*tick_resume)(struct clock_event_device *);

	void			(*broadcast)(const struct cpumask *mask);
	void			(*suspend)(struct clock_event_device *);
	void			(*resume)(struct clock_event_device *);
	unsigned long		min_delta_ticks;
	unsigned long		max_delta_ticks;

	const char		*name;
	int			rating;
	int			irq;
	int			bound_on;
	const struct cpumask	*cpumask;
	struct list_head	list;
	struct module		*owner;
} ____cacheline_aligned;

/*
 * Calculate a multiplication factor for scaled math, which is used to convert
 * nanoseconds based values to clock ticks:
 *
 * clock_ticks = (nanoseconds * factor) >> shift.
 *
 * div_sc is the rearranged equation to calculate a factor from a given clock
 * ticks / nanoseconds ratio:
 *
 * factor = (clock_ticks << shift) / nanoseconds
 */
static inline unsigned long div_sc(unsigned long ticks, unsigned long nsec,
				   int shift)
{
	uint64_t tmp = ((uint64_t)ticks) << shift;

	do_div(tmp, nsec);
	return (unsigned long) tmp;
}

/* Clock event layer functions */
extern u64 clockevent_delta2ns(unsigned long latch,
			       struct clock_event_device *evt);
extern void clockevents_register_device(struct clock_event_device *dev);
extern int clockevents_unbind_device(struct clock_event_device *ced, int cpu);

extern void clockevents_config(struct clock_event_device *dev, u32 freq);
extern void clockevents_config_and_register(struct clock_event_device *dev,
					    u32 freq, unsigned long min_delta,
					    unsigned long max_delta);

extern int clockevents_update_freq(struct clock_event_device *ce, u32 freq);

extern void clockevents_exchange_device(struct clock_event_device *old,
					struct clock_event_device *new);
extern void clockevents_set_state(struct clock_event_device *dev,
				  enum clock_event_state state);
extern int clockevents_program_event(struct clock_event_device *dev,
				     ktime_t expires, bool force);

extern void clockevents_handle_noop(struct clock_event_device *dev);

static inline void
clockevents_calc_mult_shift(struct clock_event_device *ce, u32 freq, u32 minsec)
{
	return clocks_calc_mult_shift(&ce->mult, &ce->shift, NSEC_PER_SEC,
				      freq, minsec);
}

extern void clockevents_suspend(void);
extern void clockevents_resume(void);

#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
#ifdef CONFIG_ARCH_HAS_TICK_BROADCAST
extern void tick_broadcast(const struct cpumask *mask);
#else
#define tick_broadcast	NULL
#endif
extern int tick_receive_broadcast(void);
#endif

#if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)
extern void tick_setup_hrtimer_broadcast(void);
extern int tick_check_broadcast_expired(void);
#else
static inline int tick_check_broadcast_expired(void) { return 0; }
static inline void tick_setup_hrtimer_broadcast(void) {};
#endif

#ifdef CONFIG_GENERIC_CLOCKEVENTS
extern int clockevents_notify(unsigned long reason, void *arg);
#else
static inline int clockevents_notify(unsigned long reason, void *arg) { return 0; }
#endif

#else /* CONFIG_GENERIC_CLOCKEVENTS_BUILD */

static inline void clockevents_suspend(void) {}
static inline void clockevents_resume(void) {}

static inline int clockevents_notify(unsigned long reason, void *arg) { return 0; }
static inline int tick_check_broadcast_expired(void) { return 0; }
static inline void tick_setup_hrtimer_broadcast(void) {};

#endif

#endif
Commit	Line	Data
d316c57f TG	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
4dbad816 DL	11	/* Clock event notification values */
	12	enum clock_event_nofitiers {
	13	CLOCK_EVT_NOTIFY_ADD,
	14	CLOCK_EVT_NOTIFY_BROADCAST_ON,
	15	CLOCK_EVT_NOTIFY_BROADCAST_OFF,
	16	CLOCK_EVT_NOTIFY_BROADCAST_FORCE,
	17	CLOCK_EVT_NOTIFY_BROADCAST_ENTER,
	18	CLOCK_EVT_NOTIFY_BROADCAST_EXIT,
	19	CLOCK_EVT_NOTIFY_SUSPEND,
	20	CLOCK_EVT_NOTIFY_RESUME,
	21	CLOCK_EVT_NOTIFY_CPU_DYING,
	22	CLOCK_EVT_NOTIFY_CPU_DEAD,
	23	};
	24
de68d9b1	25	#ifdef CONFIG_GENERIC_CLOCKEVENTS_BUILD
d316c57f TG	26
	27	#include <linux/clocksource.h>
	28	#include <linux/cpumask.h>
	29	#include <linux/ktime.h>
	30	#include <linux/notifier.h>
	31
	32	struct clock_event_device;
ccf33d68	33	struct module;
d316c57f	34
77e32c89	35	/* Clock event mode commands for legacy ->set_mode(): OBSOLETE */
d316c57f TG	36	enum clock_event_mode {
	37	CLOCK_EVT_MODE_UNUSED = 0,
	38	CLOCK_EVT_MODE_SHUTDOWN,
	39	CLOCK_EVT_MODE_PERIODIC,
	40	CLOCK_EVT_MODE_ONESHOT,
18de5bc4	41	CLOCK_EVT_MODE_RESUME,
77e32c89	42	};
bd624d75	43
77e32c89 VK	44	/*
	45	* Possible states of a clock event device.
	46	*
	47	* DETACHED: Device is not used by clockevents core. Initial state or can be
	48	* reached from SHUTDOWN.
	49	* SHUTDOWN: Device is powered-off. Can be reached from PERIODIC or ONESHOT.
	50	* PERIODIC: Device is programmed to generate events periodically. Can be
	51	* reached from DETACHED or SHUTDOWN.
	52	* ONESHOT: Device is programmed to generate event only once. Can be reached
	53	* from DETACHED or SHUTDOWN.
	54	*/
	55	enum clock_event_state {
	56	CLOCK_EVT_STATE_DETACHED = 0,
	57	CLOCK_EVT_STATE_SHUTDOWN,
	58	CLOCK_EVT_STATE_PERIODIC,
	59	CLOCK_EVT_STATE_ONESHOT,
d316c57f TG	60	};
d316c57f TG	61
d316c57f TG	62	/*
	63	* Clock event features
	64	*/
	65	#define CLOCK_EVT_FEAT_PERIODIC 0x000001
	66	#define CLOCK_EVT_FEAT_ONESHOT 0x000002
65516f8a	67	#define CLOCK_EVT_FEAT_KTIME 0x000004
d316c57f TG	68	/*
	69	* x86(64) specific misfeatures:
	70	*
	71	* - Clockevent source stops in C3 State and needs broadcast support.
	72	* - Local APIC timer is used as a dummy device.
	73	*/
65516f8a MS	74	#define CLOCK_EVT_FEAT_C3STOP 0x000008
65516f8a MS	75	#define CLOCK_EVT_FEAT_DUMMY 0x000010
d316c57f	76
d2348fb6 DL	77	/*
	78	* Core shall set the interrupt affinity dynamically in broadcast mode
	79	*/
	80	#define CLOCK_EVT_FEAT_DYNIRQ 0x000020
3713c0cf	81	#define CLOCK_EVT_FEAT_PERCPU 0x000040
d2348fb6	82
5d1638ac PM	83	/*
	84	* Clockevent device is based on a hrtimer for broadcast
	85	*/
	86	#define CLOCK_EVT_FEAT_HRTIMER 0x000080
	87
d316c57f TG	88	/**
d316c57f TG	89	* struct clock_event_device - clock event device descriptor
847b2f42 TG	90	* @event_handler: Assigned by the framework to be called by the low
847b2f42 TG	91	* level handler of the event source
65516f8a MS	92	* @set_next_event: set next event function using a clocksource delta
65516f8a MS	93	* @set_next_ktime: set next event function using a direct ktime value
847b2f42	94	* @next_event: local storage for the next event in oneshot mode
d316c57f TG	95	* @max_delta_ns: maximum delta value in ns
	96	* @min_delta_ns: minimum delta value in ns
	97	* @mult: nanosecond to cycles multiplier
	98	* @shift: nanoseconds to cycles divisor (power of two)
77e32c89 VK	99	* @mode: operating mode, relevant only to ->set_mode(), OBSOLETE
77e32c89 VK	100	* @state: current state of the device, assigned by the core code
847b2f42 TG	101	* @features: features
847b2f42 TG	102	* @retries: number of forced programming retries
bd624d75	103	* @set_mode: legacy set mode function, only for modes <= CLOCK_EVT_MODE_RESUME.
77e32c89 VK	104	* @set_state_periodic: switch state to periodic, if !set_mode
	105	* @set_state_oneshot: switch state to oneshot, if !set_mode
	106	* @set_state_shutdown: switch state to shutdown, if !set_mode
554ef387	107	* @tick_resume: resume clkevt device, if !set_mode
847b2f42	108	* @broadcast: function to broadcast events
57f0fcbe TG	109	* @min_delta_ticks: minimum delta value in ticks stored for reconfiguration
57f0fcbe TG	110	* @max_delta_ticks: maximum delta value in ticks stored for reconfiguration
847b2f42	111	* @name: ptr to clock event name
d316c57f	112	* @rating: variable to rate clock event devices
ce0be127	113	* @irq: IRQ number (only for non CPU local devices)
5d1638ac	114	* @bound_on: Bound on CPU
ce0be127	115	* @cpumask: cpumask to indicate for which CPUs this device works
d316c57f	116	* @list: list head for the management code
ccf33d68	117	* @owner: module reference
d316c57f TG	118	*/
d316c57f TG	119	struct clock_event_device {
847b2f42 TG	120	void (event_handler)(struct clock_event_device );
	121	int (*set_next_event)(unsigned long evt,
	122	struct clock_event_device *);
65516f8a MS	123	int (*set_next_ktime)(ktime_t expires,
65516f8a MS	124	struct clock_event_device *);
847b2f42	125	ktime_t next_event;
97813f2f JH	126	u64 max_delta_ns;
97813f2f JH	127	u64 min_delta_ns;
23af368e TG	128	u32 mult;
23af368e TG	129	u32 shift;
847b2f42	130	enum clock_event_mode mode;
77e32c89	131	enum clock_event_state state;
847b2f42 TG	132	unsigned int features;
	133	unsigned long retries;
	134
bd624d75	135	/*
77e32c89	136	* State transition callback(s): Only one of the two groups should be
bd624d75 VK	137	* defined:
bd624d75 VK	138	* - set_mode(), only for modes <= CLOCK_EVT_MODE_RESUME.
77e32c89	139	* - set_state_{shutdown\|periodic\|oneshot}(), tick_resume().
bd624d75	140	*/
847b2f42 TG	141	void (*set_mode)(enum clock_event_mode mode,
847b2f42 TG	142	struct clock_event_device *);
77e32c89 VK	143	int (set_state_periodic)(struct clock_event_device );
	144	int (set_state_oneshot)(struct clock_event_device );
	145	int (set_state_shutdown)(struct clock_event_device );
554ef387	146	int (tick_resume)(struct clock_event_device );
bd624d75 VK	147
bd624d75 VK	148	void (broadcast)(const struct cpumask mask);
adc78e6b RW	149	void (suspend)(struct clock_event_device );
adc78e6b RW	150	void (resume)(struct clock_event_device );
57f0fcbe TG	151	unsigned long min_delta_ticks;
	152	unsigned long max_delta_ticks;
	153
847b2f42	154	const char *name;
d316c57f TG	155	int rating;
d316c57f TG	156	int irq;
5d1638ac	157	int bound_on;
320ab2b0	158	const struct cpumask *cpumask;
d316c57f	159	struct list_head list;
ccf33d68	160	struct module *owner;
847b2f42	161	} ____cacheline_aligned;
d316c57f TG	162
	163	/*
	164	* Calculate a multiplication factor for scaled math, which is used to convert
	165	* nanoseconds based values to clock ticks:
	166	*
	167	* clock_ticks = (nanoseconds * factor) >> shift.
	168	*
	169	* div_sc is the rearranged equation to calculate a factor from a given clock
	170	* ticks / nanoseconds ratio:
	171	*
	172	* factor = (clock_ticks << shift) / nanoseconds
	173	*/
	174	static inline unsigned long div_sc(unsigned long ticks, unsigned long nsec,
	175	int shift)
	176	{
	177	uint64_t tmp = ((uint64_t)ticks) << shift;
	178
	179	do_div(tmp, nsec);
	180	return (unsigned long) tmp;
	181	}
	182
	183	/* Clock event layer functions */
97813f2f JH	184	extern u64 clockevent_delta2ns(unsigned long latch,
97813f2f JH	185	struct clock_event_device *evt);
d316c57f	186	extern void clockevents_register_device(struct clock_event_device *dev);
03e13cf5	187	extern int clockevents_unbind_device(struct clock_event_device *ced, int cpu);
d316c57f	188
e5400321	189	extern void clockevents_config(struct clock_event_device *dev, u32 freq);
57f0fcbe TG	190	extern void clockevents_config_and_register(struct clock_event_device *dev,
	191	u32 freq, unsigned long min_delta,
	192	unsigned long max_delta);
	193
80b816b7 TG	194	extern int clockevents_update_freq(struct clock_event_device *ce, u32 freq);
80b816b7 TG	195
d316c57f TG	196	extern void clockevents_exchange_device(struct clock_event_device *old,
d316c57f TG	197	struct clock_event_device *new);
77e32c89 VK	198	extern void clockevents_set_state(struct clock_event_device *dev,
77e32c89 VK	199	enum clock_event_state state);
d316c57f	200	extern int clockevents_program_event(struct clock_event_device *dev,
d1748302	201	ktime_t expires, bool force);
d316c57f	202
7c1e7689 VP	203	extern void clockevents_handle_noop(struct clock_event_device *dev);
7c1e7689 VP	204
7d2f944a TG	205	static inline void
	206	clockevents_calc_mult_shift(struct clock_event_device *ce, u32 freq, u32 minsec)
	207	{
	208	return clocks_calc_mult_shift(&ce->mult, &ce->shift, NSEC_PER_SEC,
	209	freq, minsec);
	210	}
	211
adc78e6b RW	212	extern void clockevents_suspend(void);
	213	extern void clockevents_resume(void);
	214
12572dbb	215	#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
12ad1000 MR	216	#ifdef CONFIG_ARCH_HAS_TICK_BROADCAST
	217	extern void tick_broadcast(const struct cpumask *mask);
	218	#else
	219	#define tick_broadcast NULL
	220	#endif
12572dbb MR	221	extern int tick_receive_broadcast(void);
	222	#endif
	223
eaa907c5	224	#if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)
5d1638ac	225	extern void tick_setup_hrtimer_broadcast(void);
eaa907c5 TG	226	extern int tick_check_broadcast_expired(void);
	227	#else
	228	static inline int tick_check_broadcast_expired(void) { return 0; }
f1689bb7	229	static inline void tick_setup_hrtimer_broadcast(void) {};
eaa907c5 TG	230	#endif
eaa907c5 TG	231
de68d9b1	232	#ifdef CONFIG_GENERIC_CLOCKEVENTS
da7e6f45	233	extern int clockevents_notify(unsigned long reason, void *arg);
d316c57f	234	#else
da7e6f45	235	static inline int clockevents_notify(unsigned long reason, void *arg) { return 0; }
de68d9b1 TG	236	#endif
	237
	238	#else /* CONFIG_GENERIC_CLOCKEVENTS_BUILD */
d316c57f	239
adc78e6b RW	240	static inline void clockevents_suspend(void) {}
	241	static inline void clockevents_resume(void) {}
	242
da7e6f45	243	static inline int clockevents_notify(unsigned long reason, void *arg) { return 0; }
19919226	244	static inline int tick_check_broadcast_expired(void) { return 0; }
849401b6	245	static inline void tick_setup_hrtimer_broadcast(void) {};
d316c57f TG	246
	247	#endif
	248
	249	#endif