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 */ 23struct 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 54struct pmf_function; 55 56struct 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 */ 121struct pmf_device; 122 123struct 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 const char *name; 135 u32 phandle; 136 137 /* The flags for that function. You can have several functions 138 * with the same name and different flag 139 */ 140 u32 flags; 141 142 /* The actual tokenized function blob */ 143 const void *data; 144 unsigned int length; 145 146 /* Interrupt clients */ 147 struct list_head irq_clients; 148 149 /* Refcounting */ 150 struct kref ref; 151}; 152 153/* 154 * For platform functions that are interrupts, one can register 155 * irq_client structures. You canNOT use the same structure twice 156 * as it contains a link member. Also, the callback is called with 157 * a spinlock held, you must not call back into any of the pmf_* functions 158 * from within that callback 159 */ 160struct pmf_irq_client { 161 void (*handler)(void *data); 162 void *data; 163 struct module *owner; 164 struct list_head link; 165 struct pmf_function *func; 166}; 167 168 169/* 170 * Register/Unregister a function-capable driver and its handlers 171 */ 172extern int pmf_register_driver(struct device_node *np, 173 struct pmf_handlers *handlers, 174 void *driverdata); 175 176extern void pmf_unregister_driver(struct device_node *np); 177 178 179/* 180 * Register/Unregister interrupt clients 181 */ 182extern int pmf_register_irq_client(struct device_node *np, 183 const char *name, 184 struct pmf_irq_client *client); 185 186extern void pmf_unregister_irq_client(struct pmf_irq_client *client); 187 188/* 189 * Called by the handlers when an irq happens 190 */ 191extern void pmf_do_irq(struct pmf_function *func); 192 193 194/* 195 * Low level call to platform functions. 196 * 197 * The phandle can filter on the target object for functions that have 198 * multiple targets, the flags allow you to restrict the call to a given 199 * combination of flags. 200 * 201 * The args array contains as many arguments as is required by the function, 202 * this is dependent on the function you are calling, unfortunately Apple 203 * mechanism provides no way to encode that so you have to get it right at 204 * the call site. Some functions require no args, in which case, you can 205 * pass NULL. 206 * 207 * You can also pass NULL to the name. This will match any function that has 208 * the appropriate combination of flags & phandle or you can pass 0 to the 209 * phandle to match any 210 */ 211extern int pmf_do_functions(struct device_node *np, const char *name, 212 u32 phandle, u32 flags, struct pmf_args *args); 213 214 215 216 217extern int pmf_call_function(struct device_node *target, const char *name, 218 struct pmf_args *args); 219 220 221/* 222 * For low latency interrupt usage, you can lookup for on-demand functions 223 * using the functions below 224 */ 225 226extern struct pmf_function *pmf_find_function(struct device_node *target, 227 const char *name); 228 229extern struct pmf_function * pmf_get_function(struct pmf_function *func); 230extern void pmf_put_function(struct pmf_function *func); 231 232extern int pmf_call_one(struct pmf_function *func, struct pmf_args *args); 233 234 235/* Suspend/resume code called by via-pmu directly for now */ 236extern void pmac_pfunc_base_suspend(void); 237extern void pmac_pfunc_base_resume(void); 238 239#endif /* __PMAC_PFUNC_H__ */ 240