1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Counter interface 4 * Copyright (C) 2018 William Breathitt Gray 5 */ 6 #ifndef _COUNTER_H_ 7 #define _COUNTER_H_ 8 9 #include <linux/cdev.h> 10 #include <linux/device.h> 11 #include <linux/kernel.h> 12 #include <linux/kfifo.h> 13 #include <linux/mutex.h> 14 #include <linux/spinlock_types.h> 15 #include <linux/types.h> 16 #include <linux/wait.h> 17 #include <uapi/linux/counter.h> 18 19 struct counter_device; 20 struct counter_count; 21 struct counter_synapse; 22 struct counter_signal; 23 24 enum counter_comp_type { 25 COUNTER_COMP_U8, 26 COUNTER_COMP_U64, 27 COUNTER_COMP_BOOL, 28 COUNTER_COMP_SIGNAL_LEVEL, 29 COUNTER_COMP_FUNCTION, 30 COUNTER_COMP_SYNAPSE_ACTION, 31 COUNTER_COMP_ENUM, 32 COUNTER_COMP_COUNT_DIRECTION, 33 COUNTER_COMP_COUNT_MODE, 34 }; 35 36 /** 37 * struct counter_comp - Counter component node 38 * @type: Counter component data type 39 * @name: device-specific component name 40 * @priv: component-relevant data 41 * @action_read: Synapse action mode read callback. The read value of the 42 * respective Synapse action mode should be passed back via 43 * the action parameter. 44 * @device_u8_read: Device u8 component read callback. The read value of the 45 * respective Device u8 component should be passed back via 46 * the val parameter. 47 * @count_u8_read: Count u8 component read callback. The read value of the 48 * respective Count u8 component should be passed back via 49 * the val parameter. 50 * @signal_u8_read: Signal u8 component read callback. The read value of the 51 * respective Signal u8 component should be passed back via 52 * the val parameter. 53 * @device_u32_read: Device u32 component read callback. The read value of 54 * the respective Device u32 component should be passed 55 * back via the val parameter. 56 * @count_u32_read: Count u32 component read callback. The read value of the 57 * respective Count u32 component should be passed back via 58 * the val parameter. 59 * @signal_u32_read: Signal u32 component read callback. The read value of 60 * the respective Signal u32 component should be passed 61 * back via the val parameter. 62 * @device_u64_read: Device u64 component read callback. The read value of 63 * the respective Device u64 component should be passed 64 * back via the val parameter. 65 * @count_u64_read: Count u64 component read callback. The read value of the 66 * respective Count u64 component should be passed back via 67 * the val parameter. 68 * @signal_u64_read: Signal u64 component read callback. The read value of 69 * the respective Signal u64 component should be passed 70 * back via the val parameter. 71 * @action_write: Synapse action mode write callback. The write value of 72 * the respective Synapse action mode is passed via the 73 * action parameter. 74 * @device_u8_write: Device u8 component write callback. The write value of 75 * the respective Device u8 component is passed via the val 76 * parameter. 77 * @count_u8_write: Count u8 component write callback. The write value of 78 * the respective Count u8 component is passed via the val 79 * parameter. 80 * @signal_u8_write: Signal u8 component write callback. The write value of 81 * the respective Signal u8 component is passed via the val 82 * parameter. 83 * @device_u32_write: Device u32 component write callback. The write value of 84 * the respective Device u32 component is passed via the 85 * val parameter. 86 * @count_u32_write: Count u32 component write callback. The write value of 87 * the respective Count u32 component is passed via the val 88 * parameter. 89 * @signal_u32_write: Signal u32 component write callback. The write value of 90 * the respective Signal u32 component is passed via the 91 * val parameter. 92 * @device_u64_write: Device u64 component write callback. The write value of 93 * the respective Device u64 component is passed via the 94 * val parameter. 95 * @count_u64_write: Count u64 component write callback. The write value of 96 * the respective Count u64 component is passed via the val 97 * parameter. 98 * @signal_u64_write: Signal u64 component write callback. The write value of 99 * the respective Signal u64 component is passed via the 100 * val parameter. 101 */ 102 struct counter_comp { 103 enum counter_comp_type type; 104 const char *name; 105 void *priv; 106 union { 107 int (*action_read)(struct counter_device *counter, 108 struct counter_count *count, 109 struct counter_synapse *synapse, 110 enum counter_synapse_action *action); 111 int (*device_u8_read)(struct counter_device *counter, u8 *val); 112 int (*count_u8_read)(struct counter_device *counter, 113 struct counter_count *count, u8 *val); 114 int (*signal_u8_read)(struct counter_device *counter, 115 struct counter_signal *signal, u8 *val); 116 int (*device_u32_read)(struct counter_device *counter, 117 u32 *val); 118 int (*count_u32_read)(struct counter_device *counter, 119 struct counter_count *count, u32 *val); 120 int (*signal_u32_read)(struct counter_device *counter, 121 struct counter_signal *signal, u32 *val); 122 int (*device_u64_read)(struct counter_device *counter, 123 u64 *val); 124 int (*count_u64_read)(struct counter_device *counter, 125 struct counter_count *count, u64 *val); 126 int (*signal_u64_read)(struct counter_device *counter, 127 struct counter_signal *signal, u64 *val); 128 }; 129 union { 130 int (*action_write)(struct counter_device *counter, 131 struct counter_count *count, 132 struct counter_synapse *synapse, 133 enum counter_synapse_action action); 134 int (*device_u8_write)(struct counter_device *counter, u8 val); 135 int (*count_u8_write)(struct counter_device *counter, 136 struct counter_count *count, u8 val); 137 int (*signal_u8_write)(struct counter_device *counter, 138 struct counter_signal *signal, u8 val); 139 int (*device_u32_write)(struct counter_device *counter, 140 u32 val); 141 int (*count_u32_write)(struct counter_device *counter, 142 struct counter_count *count, u32 val); 143 int (*signal_u32_write)(struct counter_device *counter, 144 struct counter_signal *signal, u32 val); 145 int (*device_u64_write)(struct counter_device *counter, 146 u64 val); 147 int (*count_u64_write)(struct counter_device *counter, 148 struct counter_count *count, u64 val); 149 int (*signal_u64_write)(struct counter_device *counter, 150 struct counter_signal *signal, u64 val); 151 }; 152 }; 153 154 /** 155 * struct counter_signal - Counter Signal node 156 * @id: unique ID used to identify the Signal 157 * @name: device-specific Signal name 158 * @ext: optional array of Signal extensions 159 * @num_ext: number of Signal extensions specified in @ext 160 */ 161 struct counter_signal { 162 int id; 163 const char *name; 164 165 struct counter_comp *ext; 166 size_t num_ext; 167 }; 168 169 /** 170 * struct counter_synapse - Counter Synapse node 171 * @actions_list: array of available action modes 172 * @num_actions: number of action modes specified in @actions_list 173 * @signal: pointer to the associated Signal 174 */ 175 struct counter_synapse { 176 const enum counter_synapse_action *actions_list; 177 size_t num_actions; 178 179 struct counter_signal *signal; 180 }; 181 182 /** 183 * struct counter_count - Counter Count node 184 * @id: unique ID used to identify the Count 185 * @name: device-specific Count name 186 * @functions_list: array of available function modes 187 * @num_functions: number of function modes specified in @functions_list 188 * @synapses: array of Synapses for initialization 189 * @num_synapses: number of Synapses specified in @synapses 190 * @ext: optional array of Count extensions 191 * @num_ext: number of Count extensions specified in @ext 192 */ 193 struct counter_count { 194 int id; 195 const char *name; 196 197 const enum counter_function *functions_list; 198 size_t num_functions; 199 200 struct counter_synapse *synapses; 201 size_t num_synapses; 202 203 struct counter_comp *ext; 204 size_t num_ext; 205 }; 206 207 /** 208 * struct counter_event_node - Counter Event node 209 * @l: list of current watching Counter events 210 * @event: event that triggers 211 * @channel: event channel 212 * @comp_list: list of components to watch when event triggers 213 */ 214 struct counter_event_node { 215 struct list_head l; 216 u8 event; 217 u8 channel; 218 struct list_head comp_list; 219 }; 220 221 /** 222 * struct counter_ops - Callbacks from driver 223 * @signal_read: optional read callback for Signals. The read level of 224 * the respective Signal should be passed back via the 225 * level parameter. 226 * @count_read: read callback for Counts. The read value of the 227 * respective Count should be passed back via the value 228 * parameter. 229 * @count_write: optional write callback for Counts. The write value for 230 * the respective Count is passed in via the value 231 * parameter. 232 * @function_read: read callback the Count function modes. The read 233 * function mode of the respective Count should be passed 234 * back via the function parameter. 235 * @function_write: optional write callback for Count function modes. The 236 * function mode to write for the respective Count is 237 * passed in via the function parameter. 238 * @action_read: optional read callback the Synapse action modes. The 239 * read action mode of the respective Synapse should be 240 * passed back via the action parameter. 241 * @action_write: optional write callback for Synapse action modes. The 242 * action mode to write for the respective Synapse is 243 * passed in via the action parameter. 244 * @events_configure: optional write callback to configure events. The list of 245 * struct counter_event_node may be accessed via the 246 * events_list member of the counter parameter. 247 * @watch_validate: optional callback to validate a watch. The Counter 248 * component watch configuration is passed in via the watch 249 * parameter. A return value of 0 indicates a valid Counter 250 * component watch configuration. 251 */ 252 struct counter_ops { 253 int (*signal_read)(struct counter_device *counter, 254 struct counter_signal *signal, 255 enum counter_signal_level *level); 256 int (*count_read)(struct counter_device *counter, 257 struct counter_count *count, u64 *value); 258 int (*count_write)(struct counter_device *counter, 259 struct counter_count *count, u64 value); 260 int (*function_read)(struct counter_device *counter, 261 struct counter_count *count, 262 enum counter_function *function); 263 int (*function_write)(struct counter_device *counter, 264 struct counter_count *count, 265 enum counter_function function); 266 int (*action_read)(struct counter_device *counter, 267 struct counter_count *count, 268 struct counter_synapse *synapse, 269 enum counter_synapse_action *action); 270 int (*action_write)(struct counter_device *counter, 271 struct counter_count *count, 272 struct counter_synapse *synapse, 273 enum counter_synapse_action action); 274 int (*events_configure)(struct counter_device *counter); 275 int (*watch_validate)(struct counter_device *counter, 276 const struct counter_watch *watch); 277 }; 278 279 /** 280 * struct counter_device - Counter data structure 281 * @name: name of the device 282 * @parent: optional parent device providing the counters 283 * @ops: callbacks from driver 284 * @signals: array of Signals 285 * @num_signals: number of Signals specified in @signals 286 * @counts: array of Counts 287 * @num_counts: number of Counts specified in @counts 288 * @ext: optional array of Counter device extensions 289 * @num_ext: number of Counter device extensions specified in @ext 290 * @priv: optional private data supplied by driver 291 * @dev: internal device structure 292 * @chrdev: internal character device structure 293 * @events_list: list of current watching Counter events 294 * @events_list_lock: lock to protect Counter events list operations 295 * @next_events_list: list of next watching Counter events 296 * @n_events_list_lock: lock to protect Counter next events list operations 297 * @events: queue of detected Counter events 298 * @events_wait: wait queue to allow blocking reads of Counter events 299 * @events_in_lock: lock to protect Counter events queue in operations 300 * @events_out_lock: lock to protect Counter events queue out operations 301 * @ops_exist_lock: lock to prevent use during removal 302 */ 303 struct counter_device { 304 const char *name; 305 struct device *parent; 306 307 const struct counter_ops *ops; 308 309 struct counter_signal *signals; 310 size_t num_signals; 311 struct counter_count *counts; 312 size_t num_counts; 313 314 struct counter_comp *ext; 315 size_t num_ext; 316 317 struct device dev; 318 struct cdev chrdev; 319 struct list_head events_list; 320 spinlock_t events_list_lock; 321 struct list_head next_events_list; 322 struct mutex n_events_list_lock; 323 DECLARE_KFIFO_PTR(events, struct counter_event); 324 wait_queue_head_t events_wait; 325 spinlock_t events_in_lock; 326 struct mutex events_out_lock; 327 struct mutex ops_exist_lock; 328 }; 329 330 void *counter_priv(const struct counter_device *const counter); 331 332 struct counter_device *counter_alloc(size_t sizeof_priv); 333 void counter_put(struct counter_device *const counter); 334 int counter_add(struct counter_device *const counter); 335 336 void counter_unregister(struct counter_device *const counter); 337 struct counter_device *devm_counter_alloc(struct device *dev, 338 size_t sizeof_priv); 339 int devm_counter_add(struct device *dev, 340 struct counter_device *const counter); 341 void counter_push_event(struct counter_device *const counter, const u8 event, 342 const u8 channel); 343 344 #define COUNTER_COMP_DEVICE_U8(_name, _read, _write) \ 345 { \ 346 .type = COUNTER_COMP_U8, \ 347 .name = (_name), \ 348 .device_u8_read = (_read), \ 349 .device_u8_write = (_write), \ 350 } 351 #define COUNTER_COMP_COUNT_U8(_name, _read, _write) \ 352 { \ 353 .type = COUNTER_COMP_U8, \ 354 .name = (_name), \ 355 .count_u8_read = (_read), \ 356 .count_u8_write = (_write), \ 357 } 358 #define COUNTER_COMP_SIGNAL_U8(_name, _read, _write) \ 359 { \ 360 .type = COUNTER_COMP_U8, \ 361 .name = (_name), \ 362 .signal_u8_read = (_read), \ 363 .signal_u8_write = (_write), \ 364 } 365 366 #define COUNTER_COMP_DEVICE_U64(_name, _read, _write) \ 367 { \ 368 .type = COUNTER_COMP_U64, \ 369 .name = (_name), \ 370 .device_u64_read = (_read), \ 371 .device_u64_write = (_write), \ 372 } 373 #define COUNTER_COMP_COUNT_U64(_name, _read, _write) \ 374 { \ 375 .type = COUNTER_COMP_U64, \ 376 .name = (_name), \ 377 .count_u64_read = (_read), \ 378 .count_u64_write = (_write), \ 379 } 380 #define COUNTER_COMP_SIGNAL_U64(_name, _read, _write) \ 381 { \ 382 .type = COUNTER_COMP_U64, \ 383 .name = (_name), \ 384 .signal_u64_read = (_read), \ 385 .signal_u64_write = (_write), \ 386 } 387 388 #define COUNTER_COMP_DEVICE_BOOL(_name, _read, _write) \ 389 { \ 390 .type = COUNTER_COMP_BOOL, \ 391 .name = (_name), \ 392 .device_u8_read = (_read), \ 393 .device_u8_write = (_write), \ 394 } 395 #define COUNTER_COMP_COUNT_BOOL(_name, _read, _write) \ 396 { \ 397 .type = COUNTER_COMP_BOOL, \ 398 .name = (_name), \ 399 .count_u8_read = (_read), \ 400 .count_u8_write = (_write), \ 401 } 402 #define COUNTER_COMP_SIGNAL_BOOL(_name, _read, _write) \ 403 { \ 404 .type = COUNTER_COMP_BOOL, \ 405 .name = (_name), \ 406 .signal_u8_read = (_read), \ 407 .signal_u8_write = (_write), \ 408 } 409 410 struct counter_available { 411 union { 412 const u32 *enums; 413 const char *const *strs; 414 }; 415 size_t num_items; 416 }; 417 418 #define DEFINE_COUNTER_AVAILABLE(_name, _enums) \ 419 struct counter_available _name = { \ 420 .enums = (_enums), \ 421 .num_items = ARRAY_SIZE(_enums), \ 422 } 423 424 #define DEFINE_COUNTER_ENUM(_name, _strs) \ 425 struct counter_available _name = { \ 426 .strs = (_strs), \ 427 .num_items = ARRAY_SIZE(_strs), \ 428 } 429 430 #define COUNTER_COMP_DEVICE_ENUM(_name, _get, _set, _available) \ 431 { \ 432 .type = COUNTER_COMP_ENUM, \ 433 .name = (_name), \ 434 .device_u32_read = (_get), \ 435 .device_u32_write = (_set), \ 436 .priv = &(_available), \ 437 } 438 #define COUNTER_COMP_COUNT_ENUM(_name, _get, _set, _available) \ 439 { \ 440 .type = COUNTER_COMP_ENUM, \ 441 .name = (_name), \ 442 .count_u32_read = (_get), \ 443 .count_u32_write = (_set), \ 444 .priv = &(_available), \ 445 } 446 #define COUNTER_COMP_SIGNAL_ENUM(_name, _get, _set, _available) \ 447 { \ 448 .type = COUNTER_COMP_ENUM, \ 449 .name = (_name), \ 450 .signal_u32_read = (_get), \ 451 .signal_u32_write = (_set), \ 452 .priv = &(_available), \ 453 } 454 455 #define COUNTER_COMP_CEILING(_read, _write) \ 456 COUNTER_COMP_COUNT_U64("ceiling", _read, _write) 457 458 #define COUNTER_COMP_COUNT_MODE(_read, _write, _available) \ 459 { \ 460 .type = COUNTER_COMP_COUNT_MODE, \ 461 .name = "count_mode", \ 462 .count_u32_read = (_read), \ 463 .count_u32_write = (_write), \ 464 .priv = &(_available), \ 465 } 466 467 #define COUNTER_COMP_DIRECTION(_read) \ 468 { \ 469 .type = COUNTER_COMP_COUNT_DIRECTION, \ 470 .name = "direction", \ 471 .count_u32_read = (_read), \ 472 } 473 474 #define COUNTER_COMP_ENABLE(_read, _write) \ 475 COUNTER_COMP_COUNT_BOOL("enable", _read, _write) 476 477 #define COUNTER_COMP_FLOOR(_read, _write) \ 478 COUNTER_COMP_COUNT_U64("floor", _read, _write) 479 480 #define COUNTER_COMP_PRESET(_read, _write) \ 481 COUNTER_COMP_COUNT_U64("preset", _read, _write) 482 483 #define COUNTER_COMP_PRESET_ENABLE(_read, _write) \ 484 COUNTER_COMP_COUNT_BOOL("preset_enable", _read, _write) 485 486 #endif /* _COUNTER_H_ */ 487