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