[GitHub/mt8127/android_kernel_alcatel_ttab.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

/**
 * 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)
 * @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;
	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 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 int tick_check_broadcast_expired(void);
#else
static inline int tick_check_broadcast_expired(void) { return 0; }
#endif

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

#else /* CONFIG_GENERIC_CLOCKEVENTS_BUILD */

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

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

#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;
409d4ffa	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
	63
d316c57f TG	64	/**
d316c57f TG	65	* struct clock_event_device - clock event device descriptor
847b2f42 TG	66	* @event_handler: Assigned by the framework to be called by the low
847b2f42 TG	67	* level handler of the event source
65516f8a MS	68	* @set_next_event: set next event function using a clocksource delta
65516f8a MS	69	* @set_next_ktime: set next event function using a direct ktime value
847b2f42	70	* @next_event: local storage for the next event in oneshot mode
d316c57f TG	71	* @max_delta_ns: maximum delta value in ns
	72	* @min_delta_ns: minimum delta value in ns
	73	* @mult: nanosecond to cycles multiplier
	74	* @shift: nanoseconds to cycles divisor (power of two)
847b2f42 TG	75	* @mode: operating mode assigned by the management code
	76	* @features: features
	77	* @retries: number of forced programming retries
	78	* @set_mode: set mode function
	79	* @broadcast: function to broadcast events
57f0fcbe TG	80	* @min_delta_ticks: minimum delta value in ticks stored for reconfiguration
57f0fcbe TG	81	* @max_delta_ticks: maximum delta value in ticks stored for reconfiguration
847b2f42	82	* @name: ptr to clock event name
d316c57f	83	* @rating: variable to rate clock event devices
ce0be127 SS	84	* @irq: IRQ number (only for non CPU local devices)
ce0be127 SS	85	* @cpumask: cpumask to indicate for which CPUs this device works
d316c57f	86	* @list: list head for the management code
409d4ffa	87	* @owner: module reference
d316c57f TG	88	*/
d316c57f TG	89	struct clock_event_device {
847b2f42 TG	90	void (event_handler)(struct clock_event_device );
	91	int (*set_next_event)(unsigned long evt,
	92	struct clock_event_device *);
65516f8a MS	93	int (*set_next_ktime)(ktime_t expires,
65516f8a MS	94	struct clock_event_device *);
847b2f42	95	ktime_t next_event;
97813f2f JH	96	u64 max_delta_ns;
97813f2f JH	97	u64 min_delta_ns;
23af368e TG	98	u32 mult;
23af368e TG	99	u32 shift;
847b2f42 TG	100	enum clock_event_mode mode;
	101	unsigned int features;
	102	unsigned long retries;
	103
	104	void (broadcast)(const struct cpumask mask);
	105	void (*set_mode)(enum clock_event_mode mode,
	106	struct clock_event_device *);
adc78e6b RW	107	void (suspend)(struct clock_event_device );
adc78e6b RW	108	void (resume)(struct clock_event_device );
57f0fcbe TG	109	unsigned long min_delta_ticks;
	110	unsigned long max_delta_ticks;
	111
847b2f42	112	const char *name;
d316c57f TG	113	int rating;
d316c57f TG	114	int irq;
320ab2b0	115	const struct cpumask *cpumask;
d316c57f	116	struct list_head list;
409d4ffa	117	struct module *owner;
847b2f42	118	} ____cacheline_aligned;
d316c57f TG	119
	120	/*
	121	* Calculate a multiplication factor for scaled math, which is used to convert
	122	* nanoseconds based values to clock ticks:
	123	*
	124	* clock_ticks = (nanoseconds * factor) >> shift.
	125	*
	126	* div_sc is the rearranged equation to calculate a factor from a given clock
	127	* ticks / nanoseconds ratio:
	128	*
	129	* factor = (clock_ticks << shift) / nanoseconds
	130	*/
	131	static inline unsigned long div_sc(unsigned long ticks, unsigned long nsec,
	132	int shift)
	133	{
	134	uint64_t tmp = ((uint64_t)ticks) << shift;
	135
	136	do_div(tmp, nsec);
	137	return (unsigned long) tmp;
	138	}
	139
	140	/* Clock event layer functions */
97813f2f JH	141	extern u64 clockevent_delta2ns(unsigned long latch,
97813f2f JH	142	struct clock_event_device *evt);
d316c57f TG	143	extern void clockevents_register_device(struct clock_event_device *dev);
d316c57f TG	144
e5400321	145	extern void clockevents_config(struct clock_event_device *dev, u32 freq);
57f0fcbe TG	146	extern void clockevents_config_and_register(struct clock_event_device *dev,
	147	u32 freq, unsigned long min_delta,
	148	unsigned long max_delta);
	149
80b816b7 TG	150	extern int clockevents_update_freq(struct clock_event_device *ce, u32 freq);
80b816b7 TG	151
d316c57f TG	152	extern void clockevents_exchange_device(struct clock_event_device *old,
d316c57f TG	153	struct clock_event_device *new);
d316c57f TG	154	extern void clockevents_set_mode(struct clock_event_device *dev,
d316c57f TG	155	enum clock_event_mode mode);
d316c57f	156	extern int clockevents_program_event(struct clock_event_device *dev,
d1748302	157	ktime_t expires, bool force);
d316c57f	158
7c1e7689 VP	159	extern void clockevents_handle_noop(struct clock_event_device *dev);
7c1e7689 VP	160
7d2f944a TG	161	static inline void
	162	clockevents_calc_mult_shift(struct clock_event_device *ce, u32 freq, u32 minsec)
	163	{
	164	return clocks_calc_mult_shift(&ce->mult, &ce->shift, NSEC_PER_SEC,
	165	freq, minsec);
	166	}
	167
adc78e6b RW	168	extern void clockevents_suspend(void);
	169	extern void clockevents_resume(void);
	170
12572dbb	171	#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
12ad1000 MR	172	#ifdef CONFIG_ARCH_HAS_TICK_BROADCAST
	173	extern void tick_broadcast(const struct cpumask *mask);
	174	#else
	175	#define tick_broadcast NULL
	176	#endif
12572dbb MR	177	extern int tick_receive_broadcast(void);
	178	#endif
	179
eaa907c5 TG	180	#if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)
	181	extern int tick_check_broadcast_expired(void);
	182	#else
	183	static inline int tick_check_broadcast_expired(void) { return 0; }
	184	#endif
	185
de68d9b1	186	#ifdef CONFIG_GENERIC_CLOCKEVENTS
d316c57f	187	extern void clockevents_notify(unsigned long reason, void *arg);
d316c57f	188	#else
4dbad816	189	static inline void clockevents_notify(unsigned long reason, void *arg) {}
de68d9b1 TG	190	#endif
	191
	192	#else /* CONFIG_GENERIC_CLOCKEVENTS_BUILD */
d316c57f	193
adc78e6b RW	194	static inline void clockevents_suspend(void) {}
	195	static inline void clockevents_resume(void) {}
	196
4dbad816	197	static inline void clockevents_notify(unsigned long reason, void *arg) {}
19919226	198	static inline int tick_check_broadcast_expired(void) { return 0; }
d316c57f TG	199
	200	#endif
	201
	202	#endif