[thirdparty/kernel/linux.git] / arch / powerpc / include / asm / pmac_pfunc.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __PMAC_PFUNC_H__
#define __PMAC_PFUNC_H__

#include <linux/types.h>
#include <linux/list.h>

/* Flags in command lists */
#define PMF_FLAGS_ON_INIT		0x80000000u
#define PMF_FLGAS_ON_TERM		0x40000000u
#define PMF_FLAGS_ON_SLEEP		0x20000000u
#define PMF_FLAGS_ON_WAKE		0x10000000u
#define PMF_FLAGS_ON_DEMAND		0x08000000u
#define PMF_FLAGS_INT_GEN		0x04000000u
#define PMF_FLAGS_HIGH_SPEED		0x02000000u
#define PMF_FLAGS_LOW_SPEED		0x01000000u
#define PMF_FLAGS_SIDE_EFFECTS		0x00800000u

/*
 * Arguments to a platform function call.
 *
 * NOTE: By convention, pointer arguments point to an u32
 */
struct pmf_args {
	union {
		u32 v;
		u32 *p;
	} u[4];
	unsigned int count;
};

/*
 * A driver capable of interpreting commands provides a handlers
 * structure filled with whatever handlers are implemented by this
 * driver. Non implemented handlers are left NULL.
 *
 * PMF_STD_ARGS are the same arguments that are passed to the parser
 * and that gets passed back to the various handlers.
 *
 * Interpreting a given function always start with a begin() call which
 * returns an instance data to be passed around subsequent calls, and
 * ends with an end() call. This allows the low level driver to implement
 * locking policy or per-function instance data.
 *
 * For interrupt capable functions, irq_enable() is called when a client
 * registers, and irq_disable() is called when the last client unregisters
 * Note that irq_enable & irq_disable are called within a semaphore held
 * by the core, thus you should not try to register yourself to some other
 * pmf interrupt during those calls.
 */

#define PMF_STD_ARGS	struct pmf_function *func, void *instdata, \
		        struct pmf_args *args

struct pmf_function;

struct pmf_handlers {
	void * (*begin)(struct pmf_function *func, struct pmf_args *args);
	void (*end)(struct pmf_function *func, void *instdata);

	int (*irq_enable)(struct pmf_function *func);
	int (*irq_disable)(struct pmf_function *func);

	int (*write_gpio)(PMF_STD_ARGS, u8 value, u8 mask);
	int (*read_gpio)(PMF_STD_ARGS, u8 mask, int rshift, u8 xor);

	int (*write_reg32)(PMF_STD_ARGS, u32 offset, u32 value, u32 mask);
	int (*read_reg32)(PMF_STD_ARGS, u32 offset);
	int (*write_reg16)(PMF_STD_ARGS, u32 offset, u16 value, u16 mask);
	int (*read_reg16)(PMF_STD_ARGS, u32 offset);
	int (*write_reg8)(PMF_STD_ARGS, u32 offset, u8 value, u8 mask);
	int (*read_reg8)(PMF_STD_ARGS, u32 offset);

	int (*delay)(PMF_STD_ARGS, u32 duration);

	int (*wait_reg32)(PMF_STD_ARGS, u32 offset, u32 value, u32 mask);
	int (*wait_reg16)(PMF_STD_ARGS, u32 offset, u16 value, u16 mask);
	int (*wait_reg8)(PMF_STD_ARGS, u32 offset, u8 value, u8 mask);

	int (*read_i2c)(PMF_STD_ARGS, u32 len);
	int (*write_i2c)(PMF_STD_ARGS, u32 len, const u8 *data);
	int (*rmw_i2c)(PMF_STD_ARGS, u32 masklen, u32 valuelen, u32 totallen,
		       const u8 *maskdata, const u8 *valuedata);

	int (*read_cfg)(PMF_STD_ARGS, u32 offset, u32 len);
	int (*write_cfg)(PMF_STD_ARGS, u32 offset, u32 len, const u8 *data);
	int (*rmw_cfg)(PMF_STD_ARGS, u32 offset, u32 masklen, u32 valuelen,
		       u32 totallen, const u8 *maskdata, const u8 *valuedata);

	int (*read_i2c_sub)(PMF_STD_ARGS, u8 subaddr, u32 len);
	int (*write_i2c_sub)(PMF_STD_ARGS, u8 subaddr, u32 len, const u8 *data);
	int (*set_i2c_mode)(PMF_STD_ARGS, int mode);
	int (*rmw_i2c_sub)(PMF_STD_ARGS, u8 subaddr, u32 masklen, u32 valuelen,
			   u32 totallen, const u8 *maskdata,
			   const u8 *valuedata);

	int (*read_reg32_msrx)(PMF_STD_ARGS, u32 offset, u32 mask, u32 shift,
			       u32 xor);
	int (*read_reg16_msrx)(PMF_STD_ARGS, u32 offset, u32 mask, u32 shift,
			       u32 xor);
	int (*read_reg8_msrx)(PMF_STD_ARGS, u32 offset, u32 mask, u32 shift,
			      u32 xor);

	int (*write_reg32_slm)(PMF_STD_ARGS, u32 offset, u32 shift, u32 mask);
	int (*write_reg16_slm)(PMF_STD_ARGS, u32 offset, u32 shift, u32 mask);
	int (*write_reg8_slm)(PMF_STD_ARGS, u32 offset, u32 shift, u32 mask);

	int (*mask_and_compare)(PMF_STD_ARGS, u32 len, const u8 *maskdata,
				const u8 *valuedata);

	struct module *owner;
};


/*
 * Drivers who expose platform functions register at init time, this
 * causes the platform functions for that device node to be parsed in
 * advance and associated with the device. The data structures are
 * partially public so a driver can walk the list of platform functions
 * and eventually inspect the flags
 */
struct pmf_device;

struct pmf_function {
	/* All functions for a given driver are linked */
	struct list_head	link;

	/* Function node & driver data */
	struct device_node	*node;
	void			*driver_data;

	/* For internal use by core */
	struct pmf_device	*dev;

	/* The name is the "xxx" in "platform-do-xxx", this is how
	 * platform functions are identified by this code. Some functions
	 * only operate for a given target, in which case the phandle is
	 * here (or 0 if the filter doesn't apply)
	 */
	const char		*name;
	u32			phandle;

	/* The flags for that function. You can have several functions
	 * with the same name and different flag
	 */
	u32			flags;

	/* The actual tokenized function blob */
	const void		*data;
	unsigned int		length;

	/* Interrupt clients */
	struct list_head	irq_clients;

	/* Refcounting */
	struct kref		ref;
};

/*
 * For platform functions that are interrupts, one can register
 * irq_client structures. You canNOT use the same structure twice
 * as it contains a link member. Also, the callback is called with
 * a spinlock held, you must not call back into any of the pmf_* functions
 * from within that callback
 */
struct pmf_irq_client {
	void			(*handler)(void *data);
	void			*data;
	struct module		*owner;
	struct list_head	link;
	struct pmf_function	*func;
};


/*
 * Register/Unregister a function-capable driver and its handlers
 */
extern int pmf_register_driver(struct device_node *np,
			      struct pmf_handlers *handlers,
			      void *driverdata);

extern void pmf_unregister_driver(struct device_node *np);


/*
 * Register/Unregister interrupt clients
 */
extern int pmf_register_irq_client(struct device_node *np,
				   const char *name,
				   struct pmf_irq_client *client);

extern void pmf_unregister_irq_client(struct pmf_irq_client *client);

/*
 * Called by the handlers when an irq happens
 */
extern void pmf_do_irq(struct pmf_function *func);


/*
 * Low level call to platform functions.
 *
 * The phandle can filter on the target object for functions that have
 * multiple targets, the flags allow you to restrict the call to a given
 * combination of flags.
 *
 * The args array contains as many arguments as is required by the function,
 * this is dependent on the function you are calling, unfortunately Apple
 * mechanism provides no way to encode that so you have to get it right at
 * the call site. Some functions require no args, in which case, you can
 * pass NULL.
 *
 * You can also pass NULL to the name. This will match any function that has
 * the appropriate combination of flags & phandle or you can pass 0 to the
 * phandle to match any
 */
extern int pmf_do_functions(struct device_node *np, const char *name,
			    u32 phandle, u32 flags, struct pmf_args *args);


/*
 * High level call to a platform function.
 *
 * This one looks for the platform-xxx first so you should call it to the
 * actual target if any. It will fallback to platform-do-xxx if it can't
 * find one. It will also exclusively target functions that have
 * the "OnDemand" flag.
 */

extern int pmf_call_function(struct device_node *target, const char *name,
			     struct pmf_args *args);


/*
 * For low latency interrupt usage, you can lookup for on-demand functions
 * using the functions below
 */

extern struct pmf_function *pmf_find_function(struct device_node *target,
					      const char *name);

extern struct pmf_function * pmf_get_function(struct pmf_function *func);
extern void pmf_put_function(struct pmf_function *func);

extern int pmf_call_one(struct pmf_function *func, struct pmf_args *args);


/* Suspend/resume code called by via-pmu directly for now */
extern void pmac_pfunc_base_suspend(void);
extern void pmac_pfunc_base_resume(void);

#endif /* __PMAC_PFUNC_H__ */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
5b9ca526 BH	2	#ifndef __PMAC_PFUNC_H__
	3	#define __PMAC_PFUNC_H__
	4
	5	#include <linux/types.h>
	6	#include <linux/list.h>
	7
	8	/* Flags in command lists */
	9	#define PMF_FLAGS_ON_INIT 0x80000000u
	10	#define PMF_FLGAS_ON_TERM 0x40000000u
	11	#define PMF_FLAGS_ON_SLEEP 0x20000000u
	12	#define PMF_FLAGS_ON_WAKE 0x10000000u
	13	#define PMF_FLAGS_ON_DEMAND 0x08000000u
	14	#define PMF_FLAGS_INT_GEN 0x04000000u
	15	#define PMF_FLAGS_HIGH_SPEED 0x02000000u
	16	#define PMF_FLAGS_LOW_SPEED 0x01000000u
	17	#define PMF_FLAGS_SIDE_EFFECTS 0x00800000u
	18
	19	/*
	20	* Arguments to a platform function call.
	21	*
	22	* NOTE: By convention, pointer arguments point to an u32
	23	*/
	24	struct pmf_args {
	25	union {
	26	u32 v;
	27	u32 *p;
	28	} u[4];
	29	unsigned int count;
	30	};
	31
	32	/*
	33	* A driver capable of interpreting commands provides a handlers
	34	* structure filled with whatever handlers are implemented by this
	35	* driver. Non implemented handlers are left NULL.
	36	*
	37	* PMF_STD_ARGS are the same arguments that are passed to the parser
	38	* and that gets passed back to the various handlers.
	39	*
	40	* Interpreting a given function always start with a begin() call which
	41	* returns an instance data to be passed around subsequent calls, and
	42	* ends with an end() call. This allows the low level driver to implement
	43	* locking policy or per-function instance data.
	44	*
	45	* For interrupt capable functions, irq_enable() is called when a client
	46	* registers, and irq_disable() is called when the last client unregisters
	47	* Note that irq_enable & irq_disable are called within a semaphore held
	48	* by the core, thus you should not try to register yourself to some other
	49	* pmf interrupt during those calls.
	50	*/
	51
	52	#define PMF_STD_ARGS struct pmf_function func, void instdata, \
	53	struct pmf_args *args
	54
	55	struct pmf_function;
	56
	57	struct pmf_handlers {
	58	void * (begin)(struct pmf_function func, struct pmf_args *args);
	59	void (end)(struct pmf_function func, void *instdata);
	60
	61	int (irq_enable)(struct pmf_function func);
	62	int (irq_disable)(struct pmf_function func);
	63
	64	int (*write_gpio)(PMF_STD_ARGS, u8 value, u8 mask);
	65	int (*read_gpio)(PMF_STD_ARGS, u8 mask, int rshift, u8 xor);
66
67	int (*write_reg32)(PMF_STD_ARGS, u32 offset, u32 value, u32 mask);
68	int (*read_reg32)(PMF_STD_ARGS, u32 offset);
69	int (*write_reg16)(PMF_STD_ARGS, u32 offset, u16 value, u16 mask);
70	int (*read_reg16)(PMF_STD_ARGS, u32 offset);
71	int (*write_reg8)(PMF_STD_ARGS, u32 offset, u8 value, u8 mask);
72	int (*read_reg8)(PMF_STD_ARGS, u32 offset);
73
74	int (*delay)(PMF_STD_ARGS, u32 duration);
75
76	int (*wait_reg32)(PMF_STD_ARGS, u32 offset, u32 value, u32 mask);
77	int (*wait_reg16)(PMF_STD_ARGS, u32 offset, u16 value, u16 mask);
78	int (*wait_reg8)(PMF_STD_ARGS, u32 offset, u8 value, u8 mask);
79
80	int (*read_i2c)(PMF_STD_ARGS, u32 len);
81	int (write_i2c)(PMF_STD_ARGS, u32 len, const u8 data);
82	int (*rmw_i2c)(PMF_STD_ARGS, u32 masklen, u32 valuelen, u32 totallen,
83	const u8 maskdata, const u8 valuedata);
84
85	int (*read_cfg)(PMF_STD_ARGS, u32 offset, u32 len);
86	int (write_cfg)(PMF_STD_ARGS, u32 offset, u32 len, const u8 data);
87	int (*rmw_cfg)(PMF_STD_ARGS, u32 offset, u32 masklen, u32 valuelen,
88	u32 totallen, const u8 maskdata, const u8 valuedata);
89
90	int (*read_i2c_sub)(PMF_STD_ARGS, u8 subaddr, u32 len);
91	int (write_i2c_sub)(PMF_STD_ARGS, u8 subaddr, u32 len, const u8 data);
92	int (*set_i2c_mode)(PMF_STD_ARGS, int mode);
93	int (*rmw_i2c_sub)(PMF_STD_ARGS, u8 subaddr, u32 masklen, u32 valuelen,
94	u32 totallen, const u8 *maskdata,
95	const u8 *valuedata);
96
97	int (*read_reg32_msrx)(PMF_STD_ARGS, u32 offset, u32 mask, u32 shift,
98	u32 xor);
99	int (*read_reg16_msrx)(PMF_STD_ARGS, u32 offset, u32 mask, u32 shift,
100	u32 xor);
101	int (*read_reg8_msrx)(PMF_STD_ARGS, u32 offset, u32 mask, u32 shift,
102	u32 xor);
103
104	int (*write_reg32_slm)(PMF_STD_ARGS, u32 offset, u32 shift, u32 mask);
105	int (*write_reg16_slm)(PMF_STD_ARGS, u32 offset, u32 shift, u32 mask);
106	int (*write_reg8_slm)(PMF_STD_ARGS, u32 offset, u32 shift, u32 mask);
107
108	int (mask_and_compare)(PMF_STD_ARGS, u32 len, const u8 maskdata,
109	const u8 *valuedata);
110
111	struct module *owner;
112	};
113
114
115	/*
116	* Drivers who expose platform functions register at init time, this
117	* causes the platform functions for that device node to be parsed in
118	* advance and associated with the device. The data structures are
119	* partially public so a driver can walk the list of platform functions
120	* and eventually inspect the flags
121	*/
122	struct pmf_device;
123
124	struct pmf_function {
125	/* All functions for a given driver are linked */
126	struct list_head link;
127
128	/* Function node & driver data */
129	struct device_node *node;
130	void *driver_data;
131
132	/* For internal use by core */
133	struct pmf_device *dev;
134
135	/* The name is the "xxx" in "platform-do-xxx", this is how
136	* platform functions are identified by this code. Some functions
137	* only operate for a given target, in which case the phandle is
138	* here (or 0 if the filter doesn't apply)
139	*/
140	const char *name;
141	u32 phandle;
142
143	/* The flags for that function. You can have several functions
144	* with the same name and different flag
145	*/
146	u32 flags;
147
148	/* The actual tokenized function blob */
149	const void *data;
150	unsigned int length;
151
152	/* Interrupt clients */
153	struct list_head irq_clients;
154
155	/* Refcounting */
156	struct kref ref;
157	};
158
159	/*
160	* For platform functions that are interrupts, one can register
161	* irq_client structures. You canNOT use the same structure twice
162	* as it contains a link member. Also, the callback is called with
163	* a spinlock held, you must not call back into any of the pmf_* functions
164	* from within that callback
165	*/
166	struct pmf_irq_client {
167	void (handler)(void data);
168	void *data;
169	struct module *owner;
170	struct list_head link;
cc0fa84a	171	struct pmf_function *func;
5b9ca526 BH	172	};
	173
	174
	175	/*
	176	* Register/Unregister a function-capable driver and its handlers
	177	*/
	178	extern int pmf_register_driver(struct device_node *np,
	179	struct pmf_handlers *handlers,
	180	void *driverdata);
	181
	182	extern void pmf_unregister_driver(struct device_node *np);
	183
	184
	185	/*
	186	* Register/Unregister interrupt clients
	187	*/
	188	extern int pmf_register_irq_client(struct device_node *np,
	189	const char *name,
	190	struct pmf_irq_client *client);
	191
cc0fa84a	192	extern void pmf_unregister_irq_client(struct pmf_irq_client *client);
5b9ca526 BH	193
	194	/*
	195	* Called by the handlers when an irq happens
	196	*/
	197	extern void pmf_do_irq(struct pmf_function *func);
	198
	199
	200	/*
	201	* Low level call to platform functions.
	202	*
	203	* The phandle can filter on the target object for functions that have
	204	* multiple targets, the flags allow you to restrict the call to a given
	205	* combination of flags.
	206	*
	207	* The args array contains as many arguments as is required by the function,
	208	* this is dependent on the function you are calling, unfortunately Apple
b3c2ffd5	209	* mechanism provides no way to encode that so you have to get it right at
5b9ca526 BH	210	* the call site. Some functions require no args, in which case, you can
	211	* pass NULL.
	212	*
	213	* You can also pass NULL to the name. This will match any function that has
	214	* the appropriate combination of flags & phandle or you can pass 0 to the
	215	* phandle to match any
	216	*/
	217	extern int pmf_do_functions(struct device_node np, const char name,
	218	u32 phandle, u32 flags, struct pmf_args *args);
	219
	220
	221
	222	/*
	223	* High level call to a platform function.
	224	*
	225	* This one looks for the platform-xxx first so you should call it to the
	226	* actual target if any. It will fallback to platform-do-xxx if it can't
	227	* find one. It will also exclusively target functions that have
	228	* the "OnDemand" flag.
	229	*/
	230
	231	extern int pmf_call_function(struct device_node target, const char name,
	232	struct pmf_args *args);
	233
	234
	235	/*
	236	* For low latency interrupt usage, you can lookup for on-demand functions
	237	* using the functions below
	238	*/
	239
	240	extern struct pmf_function pmf_find_function(struct device_node target,
	241	const char *name);
	242
	243	extern struct pmf_function * pmf_get_function(struct pmf_function *func);
	244	extern void pmf_put_function(struct pmf_function *func);
	245
	246	extern int pmf_call_one(struct pmf_function func, struct pmf_args args);
	247
	248
	249	/* Suspend/resume code called by via-pmu directly for now */
	250	extern void pmac_pfunc_base_suspend(void);
	251	extern void pmac_pfunc_base_resume(void);
	252
	253	#endif /* __PMAC_PFUNC_H__ */