[mirror_ubuntu-artful-kernel.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 */
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,
};

/*
 * 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 assigned by the management code
 * @features:		features
 * @retries:		number of forced programming retries
 * @set_mode:		set mode function
 * @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;
	unsigned int		features;
	unsigned long		retries;

	void			(*broadcast)(const struct cpumask *mask);
	void			(*set_mode)(enum clock_event_mode mode,
					    struct clock_event_device *);
	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_mode(struct clock_event_device *dev,
				 enum clock_event_mode mode);
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 TG	34
	35	/* Clock event mode commands */
	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,
d316c57f TG	42	};
d316c57f TG	43
d316c57f TG	44	/*
	45	* Clock event features
	46	*/
	47	#define CLOCK_EVT_FEAT_PERIODIC 0x000001
	48	#define CLOCK_EVT_FEAT_ONESHOT 0x000002
65516f8a	49	#define CLOCK_EVT_FEAT_KTIME 0x000004
d316c57f TG	50	/*
	51	* x86(64) specific misfeatures:
	52	*
	53	* - Clockevent source stops in C3 State and needs broadcast support.
	54	* - Local APIC timer is used as a dummy device.
	55	*/
65516f8a MS	56	#define CLOCK_EVT_FEAT_C3STOP 0x000008
65516f8a MS	57	#define CLOCK_EVT_FEAT_DUMMY 0x000010
d316c57f	58
d2348fb6 DL	59	/*
	60	* Core shall set the interrupt affinity dynamically in broadcast mode
	61	*/
	62	#define CLOCK_EVT_FEAT_DYNIRQ 0x000020
3713c0cf	63	#define CLOCK_EVT_FEAT_PERCPU 0x000040
d2348fb6	64
5d1638ac PM	65	/*
	66	* Clockevent device is based on a hrtimer for broadcast
	67	*/
	68	#define CLOCK_EVT_FEAT_HRTIMER 0x000080
	69
d316c57f TG	70	/**
d316c57f TG	71	* struct clock_event_device - clock event device descriptor
847b2f42 TG	72	* @event_handler: Assigned by the framework to be called by the low
847b2f42 TG	73	* level handler of the event source
65516f8a MS	74	* @set_next_event: set next event function using a clocksource delta
65516f8a MS	75	* @set_next_ktime: set next event function using a direct ktime value
847b2f42	76	* @next_event: local storage for the next event in oneshot mode
d316c57f TG	77	* @max_delta_ns: maximum delta value in ns
	78	* @min_delta_ns: minimum delta value in ns
	79	* @mult: nanosecond to cycles multiplier
	80	* @shift: nanoseconds to cycles divisor (power of two)
847b2f42 TG	81	* @mode: operating mode assigned by the management code
	82	* @features: features
	83	* @retries: number of forced programming retries
	84	* @set_mode: set mode function
	85	* @broadcast: function to broadcast events
57f0fcbe TG	86	* @min_delta_ticks: minimum delta value in ticks stored for reconfiguration
57f0fcbe TG	87	* @max_delta_ticks: maximum delta value in ticks stored for reconfiguration
847b2f42	88	* @name: ptr to clock event name
d316c57f	89	* @rating: variable to rate clock event devices
ce0be127	90	* @irq: IRQ number (only for non CPU local devices)
5d1638ac	91	* @bound_on: Bound on CPU
ce0be127	92	* @cpumask: cpumask to indicate for which CPUs this device works
d316c57f	93	* @list: list head for the management code
ccf33d68	94	* @owner: module reference
d316c57f TG	95	*/
d316c57f TG	96	struct clock_event_device {
847b2f42 TG	97	void (event_handler)(struct clock_event_device );
	98	int (*set_next_event)(unsigned long evt,
	99	struct clock_event_device *);
65516f8a MS	100	int (*set_next_ktime)(ktime_t expires,
65516f8a MS	101	struct clock_event_device *);
847b2f42	102	ktime_t next_event;
97813f2f JH	103	u64 max_delta_ns;
97813f2f JH	104	u64 min_delta_ns;
23af368e TG	105	u32 mult;
23af368e TG	106	u32 shift;
847b2f42 TG	107	enum clock_event_mode mode;
	108	unsigned int features;
	109	unsigned long retries;
	110
	111	void (broadcast)(const struct cpumask mask);
	112	void (*set_mode)(enum clock_event_mode mode,
	113	struct clock_event_device *);
adc78e6b RW	114	void (suspend)(struct clock_event_device );
adc78e6b RW	115	void (resume)(struct clock_event_device );
57f0fcbe TG	116	unsigned long min_delta_ticks;
	117	unsigned long max_delta_ticks;
	118
847b2f42	119	const char *name;
d316c57f TG	120	int rating;
d316c57f TG	121	int irq;
5d1638ac	122	int bound_on;
320ab2b0	123	const struct cpumask *cpumask;
d316c57f	124	struct list_head list;
ccf33d68	125	struct module *owner;
847b2f42	126	} ____cacheline_aligned;
d316c57f TG	127
	128	/*
	129	* Calculate a multiplication factor for scaled math, which is used to convert
	130	* nanoseconds based values to clock ticks:
	131	*
	132	* clock_ticks = (nanoseconds * factor) >> shift.
	133	*
	134	* div_sc is the rearranged equation to calculate a factor from a given clock
	135	* ticks / nanoseconds ratio:
	136	*
	137	* factor = (clock_ticks << shift) / nanoseconds
	138	*/
	139	static inline unsigned long div_sc(unsigned long ticks, unsigned long nsec,
	140	int shift)
	141	{
	142	uint64_t tmp = ((uint64_t)ticks) << shift;
	143
	144	do_div(tmp, nsec);
	145	return (unsigned long) tmp;
	146	}
	147
	148	/* Clock event layer functions */
97813f2f JH	149	extern u64 clockevent_delta2ns(unsigned long latch,
97813f2f JH	150	struct clock_event_device *evt);
d316c57f	151	extern void clockevents_register_device(struct clock_event_device *dev);
03e13cf5	152	extern int clockevents_unbind_device(struct clock_event_device *ced, int cpu);
d316c57f	153
e5400321	154	extern void clockevents_config(struct clock_event_device *dev, u32 freq);
57f0fcbe TG	155	extern void clockevents_config_and_register(struct clock_event_device *dev,
	156	u32 freq, unsigned long min_delta,
	157	unsigned long max_delta);
	158
80b816b7 TG	159	extern int clockevents_update_freq(struct clock_event_device *ce, u32 freq);
80b816b7 TG	160
d316c57f TG	161	extern void clockevents_exchange_device(struct clock_event_device *old,
d316c57f TG	162	struct clock_event_device *new);
d316c57f TG	163	extern void clockevents_set_mode(struct clock_event_device *dev,
d316c57f TG	164	enum clock_event_mode mode);
d316c57f	165	extern int clockevents_program_event(struct clock_event_device *dev,
d1748302	166	ktime_t expires, bool force);
d316c57f	167
7c1e7689 VP	168	extern void clockevents_handle_noop(struct clock_event_device *dev);
7c1e7689 VP	169
7d2f944a TG	170	static inline void
	171	clockevents_calc_mult_shift(struct clock_event_device *ce, u32 freq, u32 minsec)
	172	{
	173	return clocks_calc_mult_shift(&ce->mult, &ce->shift, NSEC_PER_SEC,
	174	freq, minsec);
	175	}
	176
adc78e6b RW	177	extern void clockevents_suspend(void);
	178	extern void clockevents_resume(void);
	179
12572dbb	180	#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
12ad1000 MR	181	#ifdef CONFIG_ARCH_HAS_TICK_BROADCAST
	182	extern void tick_broadcast(const struct cpumask *mask);
	183	#else
	184	#define tick_broadcast NULL
	185	#endif
12572dbb MR	186	extern int tick_receive_broadcast(void);
	187	#endif
	188
eaa907c5	189	#if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)
5d1638ac	190	extern void tick_setup_hrtimer_broadcast(void);
eaa907c5 TG	191	extern int tick_check_broadcast_expired(void);
	192	#else
	193	static inline int tick_check_broadcast_expired(void) { return 0; }
f1689bb7	194	static inline void tick_setup_hrtimer_broadcast(void) {};
eaa907c5 TG	195	#endif
eaa907c5 TG	196
de68d9b1	197	#ifdef CONFIG_GENERIC_CLOCKEVENTS
da7e6f45	198	extern int clockevents_notify(unsigned long reason, void *arg);
d316c57f	199	#else
da7e6f45	200	static inline int clockevents_notify(unsigned long reason, void *arg) { return 0; }
de68d9b1 TG	201	#endif
	202
	203	#else /* CONFIG_GENERIC_CLOCKEVENTS_BUILD */
d316c57f	204
adc78e6b RW	205	static inline void clockevents_suspend(void) {}
	206	static inline void clockevents_resume(void) {}
	207
da7e6f45	208	static inline int clockevents_notify(unsigned long reason, void *arg) { return 0; }
19919226	209	static inline int tick_check_broadcast_expired(void) { return 0; }
849401b6	210	static inline void tick_setup_hrtimer_broadcast(void) {};
d316c57f TG	211
	212	#endif
	213
	214	#endif