]>
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__ */ |