~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/include/asm/pmac_pfunc.h

Version: ~ [ linux-4.20-rc6 ] ~ [ linux-4.19.8 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.87 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.144 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.166 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.128 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.61 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.31.14 ] ~ [ linux-2.6.30.10 ] ~ [ linux-2.6.29.6 ] ~ [ linux-2.6.28.10 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SPDX-License-Identifier: GPL-2.0 */
  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;
171         struct pmf_function     *func;
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 
192 extern void pmf_unregister_irq_client(struct pmf_irq_client *client);
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
209  * mechanism provides no way to encode that so you have to get it right at
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 int pmac_pfunc_base_install(void);
249 
250 /* Suspend/resume code called by via-pmu directly for now */
251 extern void pmac_pfunc_base_suspend(void);
252 extern void pmac_pfunc_base_resume(void);
253 
254 #endif /* __PMAC_PFUNC_H__ */
255 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp