Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
pmac_pfunc.h
Go to the documentation of this file.
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 
62 
64  int (*read_gpio)(PMF_STD_ARGS, u8 mask, int rshift, u8 xor);
65 
72 
74 
78 
81  int (*rmw_i2c)(PMF_STD_ARGS, u32 masklen, u32 valuelen, u32 totallen,
82  const u8 *maskdata, const u8 *valuedata);
83 
86  int (*rmw_cfg)(PMF_STD_ARGS, u32 offset, u32 masklen, u32 valuelen,
87  u32 totallen, const u8 *maskdata, const u8 *valuedata);
88 
90  int (*write_i2c_sub)(PMF_STD_ARGS, u8 subaddr, u32 len, const u8 *data);
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 
97  u32 xor);
99  u32 xor);
101  u32 xor);
102 
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;
141 
142  /* The flags for that function. You can have several functions
143  * with the same name and different flag
144  */
146 
147  /* The actual tokenized function blob */
148  const void *data;
149  unsigned int length;
150 
151  /* Interrupt 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  */
166  void (*handler)(void *data);
167  void *data;
168  struct module *owner;
169  struct list_head link;
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 
191 extern void pmf_unregister_irq_client(struct pmf_irq_client *client);
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
208  * mechanism provides no way to encode that so you have to get it right at
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__ */