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