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/array_size.h> 10 #include <linux/cdev.h> 11 #include <linux/device.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 18 #include <uapi/linux/counter.h> 19 20 struct counter_device; 21 struct counter_count; 22 struct counter_synapse; 23 struct counter_signal; 24 25 enum counter_comp_type { 26 COUNTER_COMP_U8, 27 COUNTER_COMP_U64, 28 COUNTER_COMP_BOOL, 29 COUNTER_COMP_SIGNAL_LEVEL, 30 COUNTER_COMP_FUNCTION, 31 COUNTER_COMP_SYNAPSE_ACTION, 32 COUNTER_COMP_ENUM, 33 COUNTER_COMP_COUNT_DIRECTION, 34 COUNTER_COMP_COUNT_MODE, 35 COUNTER_COMP_SIGNAL_POLARITY, 36 COUNTER_COMP_ARRAY, 37 }; 38 39 /** 40 * struct counter_comp - Counter component node 41 * @type: Counter component data type 42 * @name: device-specific component name 43 * @priv: component-relevant data 44 * @action_read: Synapse action mode read callback. The read value of the 45 * respective Synapse action mode should be passed back via 46 * the action parameter. 47 * @device_u8_read: Device u8 component read callback. The read value of the 48 * respective Device u8 component should be passed back via 49 * the val parameter. 50 * @count_u8_read: Count u8 component read callback. The read value of the 51 * respective Count u8 component should be passed back via 52 * the val parameter. 53 * @signal_u8_read: Signal u8 component read callback. The read value of the 54 * respective Signal u8 component should be passed back via 55 * the val parameter. 56 * @device_u32_read: Device u32 component read callback. The read value of 57 * the respective Device u32 component should be passed 58 * back via the val parameter. 59 * @count_u32_read: Count u32 component read callback. The read value of the 60 * respective Count u32 component should be passed back via 61 * the val parameter. 62 * @signal_u32_read: Signal u32 component read callback. The read value of 63 * the respective Signal u32 component should be passed 64 * back via the val parameter. 65 * @device_u64_read: Device u64 component read callback. The read value of 66 * the respective Device u64 component should be passed 67 * back via the val parameter. 68 * @count_u64_read: Count u64 component read callback. The read value of the 69 * respective Count u64 component should be passed back via 70 * the val parameter. 71 * @signal_u64_read: Signal u64 component read callback. The read value of 72 * the respective Signal u64 component should be passed 73 * back via the val parameter. 74 * @signal_array_u32_read: Signal u32 array component read callback. The 75 * index of the respective Count u32 array 76 * component element is passed via the idx 77 * parameter. The read value of the respective 78 * Count u32 array component element should be 79 * passed back via the val parameter. 80 * @device_array_u64_read: Device u64 array component read callback. The 81 * index of the respective Device u64 array 82 * component element is passed via the idx 83 * parameter. The read value of the respective 84 * Device u64 array component element should be 85 * passed back via the val parameter. 86 * @count_array_u64_read: Count u64 array component read callback. The 87 * index of the respective Count u64 array 88 * component element is passed via the idx 89 * parameter. The read value of the respective 90 * Count u64 array component element should be 91 * passed back via the val parameter. 92 * @signal_array_u64_read: Signal u64 array component read callback. The 93 * index of the respective Count u64 array 94 * component element is passed via the idx 95 * parameter. The read value of the respective 96 * Count u64 array component element should be 97 * passed back via the val parameter. 98 * @action_write: Synapse action mode write callback. The write value of 99 * the respective Synapse action mode is passed via the 100 * action parameter. 101 * @device_u8_write: Device u8 component write callback. The write value of 102 * the respective Device u8 component is passed via the val 103 * parameter. 104 * @count_u8_write: Count u8 component write callback. The write value of 105 * the respective Count u8 component is passed via the val 106 * parameter. 107 * @signal_u8_write: Signal u8 component write callback. The write value of 108 * the respective Signal u8 component is passed via the val 109 * parameter. 110 * @device_u32_write: Device u32 component write callback. The write value of 111 * the respective Device u32 component is passed via the 112 * val parameter. 113 * @count_u32_write: Count u32 component write callback. The write value of 114 * the respective Count u32 component is passed via the val 115 * parameter. 116 * @signal_u32_write: Signal u32 component write callback. The write value of 117 * the respective Signal u32 component is passed via the 118 * val parameter. 119 * @device_u64_write: Device u64 component write callback. The write value of 120 * the respective Device u64 component is passed via the 121 * val parameter. 122 * @count_u64_write: Count u64 component write callback. The write value of 123 * the respective Count u64 component is passed via the val 124 * parameter. 125 * @signal_u64_write: Signal u64 component write callback. The write value of 126 * the respective Signal u64 component is passed via the 127 * val parameter. 128 * @signal_array_u32_write: Signal u32 array component write callback. The 129 * index of the respective Signal u32 array 130 * component element is passed via the idx 131 * parameter. The write value of the respective 132 * Signal u32 array component element is passed via 133 * the val parameter. 134 * @device_array_u64_write: Device u64 array component write callback. The 135 * index of the respective Device u64 array 136 * component element is passed via the idx 137 * parameter. The write value of the respective 138 * Device u64 array component element is passed via 139 * the val parameter. 140 * @count_array_u64_write: Count u64 array component write callback. The 141 * index of the respective Count u64 array 142 * component element is passed via the idx 143 * parameter. The write value of the respective 144 * Count u64 array component element is passed via 145 * the val parameter. 146 * @signal_array_u64_write: Signal u64 array component write callback. The 147 * index of the respective Signal u64 array 148 * component element is passed via the idx 149 * parameter. The write value of the respective 150 * Signal u64 array component element is passed via 151 * the val parameter. 152 */ 153 struct counter_comp { 154 enum counter_comp_type type; 155 const char *name; 156 void *priv; 157 union { 158 int (*action_read)(struct counter_device *counter, 159 struct counter_count *count, 160 struct counter_synapse *synapse, 161 enum counter_synapse_action *action); 162 int (*device_u8_read)(struct counter_device *counter, u8 *val); 163 int (*count_u8_read)(struct counter_device *counter, 164 struct counter_count *count, u8 *val); 165 int (*signal_u8_read)(struct counter_device *counter, 166 struct counter_signal *signal, u8 *val); 167 int (*device_u32_read)(struct counter_device *counter, 168 u32 *val); 169 int (*count_u32_read)(struct counter_device *counter, 170 struct counter_count *count, u32 *val); 171 int (*signal_u32_read)(struct counter_device *counter, 172 struct counter_signal *signal, u32 *val); 173 int (*device_u64_read)(struct counter_device *counter, 174 u64 *val); 175 int (*count_u64_read)(struct counter_device *counter, 176 struct counter_count *count, u64 *val); 177 int (*signal_u64_read)(struct counter_device *counter, 178 struct counter_signal *signal, u64 *val); 179 int (*signal_array_u32_read)(struct counter_device *counter, 180 struct counter_signal *signal, 181 size_t idx, u32 *val); 182 int (*device_array_u64_read)(struct counter_device *counter, 183 size_t idx, u64 *val); 184 int (*count_array_u64_read)(struct counter_device *counter, 185 struct counter_count *count, 186 size_t idx, u64 *val); 187 int (*signal_array_u64_read)(struct counter_device *counter, 188 struct counter_signal *signal, 189 size_t idx, u64 *val); 190 }; 191 union { 192 int (*action_write)(struct counter_device *counter, 193 struct counter_count *count, 194 struct counter_synapse *synapse, 195 enum counter_synapse_action action); 196 int (*device_u8_write)(struct counter_device *counter, u8 val); 197 int (*count_u8_write)(struct counter_device *counter, 198 struct counter_count *count, u8 val); 199 int (*signal_u8_write)(struct counter_device *counter, 200 struct counter_signal *signal, u8 val); 201 int (*device_u32_write)(struct counter_device *counter, 202 u32 val); 203 int (*count_u32_write)(struct counter_device *counter, 204 struct counter_count *count, u32 val); 205 int (*signal_u32_write)(struct counter_device *counter, 206 struct counter_signal *signal, u32 val); 207 int (*device_u64_write)(struct counter_device *counter, 208 u64 val); 209 int (*count_u64_write)(struct counter_device *counter, 210 struct counter_count *count, u64 val); 211 int (*signal_u64_write)(struct counter_device *counter, 212 struct counter_signal *signal, u64 val); 213 int (*signal_array_u32_write)(struct counter_device *counter, 214 struct counter_signal *signal, 215 size_t idx, u32 val); 216 int (*device_array_u64_write)(struct counter_device *counter, 217 size_t idx, u64 val); 218 int (*count_array_u64_write)(struct counter_device *counter, 219 struct counter_count *count, 220 size_t idx, u64 val); 221 int (*signal_array_u64_write)(struct counter_device *counter, 222 struct counter_signal *signal, 223 size_t idx, u64 val); 224 }; 225 }; 226 227 /** 228 * struct counter_signal - Counter Signal node 229 * @id: unique ID used to identify the Signal 230 * @name: device-specific Signal name 231 * @ext: optional array of Signal extensions 232 * @num_ext: number of Signal extensions specified in @ext 233 */ 234 struct counter_signal { 235 int id; 236 const char *name; 237 238 struct counter_comp *ext; 239 size_t num_ext; 240 }; 241 242 /** 243 * struct counter_synapse - Counter Synapse node 244 * @actions_list: array of available action modes 245 * @num_actions: number of action modes specified in @actions_list 246 * @signal: pointer to the associated Signal 247 */ 248 struct counter_synapse { 249 const enum counter_synapse_action *actions_list; 250 size_t num_actions; 251 252 struct counter_signal *signal; 253 }; 254 255 /** 256 * struct counter_count - Counter Count node 257 * @id: unique ID used to identify the Count 258 * @name: device-specific Count name 259 * @functions_list: array of available function modes 260 * @num_functions: number of function modes specified in @functions_list 261 * @synapses: array of Synapses for initialization 262 * @num_synapses: number of Synapses specified in @synapses 263 * @ext: optional array of Count extensions 264 * @num_ext: number of Count extensions specified in @ext 265 */ 266 struct counter_count { 267 int id; 268 const char *name; 269 270 const enum counter_function *functions_list; 271 size_t num_functions; 272 273 struct counter_synapse *synapses; 274 size_t num_synapses; 275 276 struct counter_comp *ext; 277 size_t num_ext; 278 }; 279 280 /** 281 * struct counter_event_node - Counter Event node 282 * @l: list of current watching Counter events 283 * @event: event that triggers 284 * @channel: event channel 285 * @comp_list: list of components to watch when event triggers 286 */ 287 struct counter_event_node { 288 struct list_head l; 289 u8 event; 290 u8 channel; 291 struct list_head comp_list; 292 }; 293 294 /** 295 * struct counter_ops - Callbacks from driver 296 * @signal_read: optional read callback for Signals. The read level of 297 * the respective Signal should be passed back via the 298 * level parameter. 299 * @count_read: read callback for Counts. The read value of the 300 * respective Count should be passed back via the value 301 * parameter. 302 * @count_write: optional write callback for Counts. The write value for 303 * the respective Count is passed in via the value 304 * parameter. 305 * @function_read: read callback the Count function modes. The read 306 * function mode of the respective Count should be passed 307 * back via the function parameter. 308 * @function_write: optional write callback for Count function modes. The 309 * function mode to write for the respective Count is 310 * passed in via the function parameter. 311 * @action_read: optional read callback the Synapse action modes. The 312 * read action mode of the respective Synapse should be 313 * passed back via the action parameter. 314 * @action_write: optional write callback for Synapse action modes. The 315 * action mode to write for the respective Synapse is 316 * passed in via the action parameter. 317 * @events_configure: optional write callback to configure events. The list of 318 * struct counter_event_node may be accessed via the 319 * events_list member of the counter parameter. 320 * @watch_validate: optional callback to validate a watch. The Counter 321 * component watch configuration is passed in via the watch 322 * parameter. A return value of 0 indicates a valid Counter 323 * component watch configuration. 324 */ 325 struct counter_ops { 326 int (*signal_read)(struct counter_device *counter, 327 struct counter_signal *signal, 328 enum counter_signal_level *level); 329 int (*count_read)(struct counter_device *counter, 330 struct counter_count *count, u64 *value); 331 int (*count_write)(struct counter_device *counter, 332 struct counter_count *count, u64 value); 333 int (*function_read)(struct counter_device *counter, 334 struct counter_count *count, 335 enum counter_function *function); 336 int (*function_write)(struct counter_device *counter, 337 struct counter_count *count, 338 enum counter_function function); 339 int (*action_read)(struct counter_device *counter, 340 struct counter_count *count, 341 struct counter_synapse *synapse, 342 enum counter_synapse_action *action); 343 int (*action_write)(struct counter_device *counter, 344 struct counter_count *count, 345 struct counter_synapse *synapse, 346 enum counter_synapse_action action); 347 int (*events_configure)(struct counter_device *counter); 348 int (*watch_validate)(struct counter_device *counter, 349 const struct counter_watch *watch); 350 }; 351 352 /** 353 * struct counter_device - Counter data structure 354 * @name: name of the device 355 * @parent: optional parent device providing the counters 356 * @ops: callbacks from driver 357 * @signals: array of Signals 358 * @num_signals: number of Signals specified in @signals 359 * @counts: array of Counts 360 * @num_counts: number of Counts specified in @counts 361 * @ext: optional array of Counter device extensions 362 * @num_ext: number of Counter device extensions specified in @ext 363 * @dev: internal device structure 364 * @chrdev: internal character device structure 365 * @events_list: list of current watching Counter events 366 * @events_list_lock: lock to protect Counter events list operations 367 * @next_events_list: list of next watching Counter events 368 * @n_events_list_lock: lock to protect Counter next events list operations 369 * @events: queue of detected Counter events 370 * @events_wait: wait queue to allow blocking reads of Counter events 371 * @events_in_lock: lock to protect Counter events queue in operations 372 * @events_out_lock: lock to protect Counter events queue out operations 373 * @ops_exist_lock: lock to prevent use during removal 374 */ 375 struct counter_device { 376 const char *name; 377 struct device *parent; 378 379 const struct counter_ops *ops; 380 381 struct counter_signal *signals; 382 size_t num_signals; 383 struct counter_count *counts; 384 size_t num_counts; 385 386 struct counter_comp *ext; 387 size_t num_ext; 388 389 struct device dev; 390 struct cdev chrdev; 391 struct list_head events_list; 392 spinlock_t events_list_lock; 393 struct list_head next_events_list; 394 struct mutex n_events_list_lock; 395 DECLARE_KFIFO_PTR(events, struct counter_event); 396 wait_queue_head_t events_wait; 397 spinlock_t events_in_lock; 398 struct mutex events_out_lock; 399 struct mutex ops_exist_lock; 400 }; 401 402 void *counter_priv(const struct counter_device *const counter) __attribute_const__; 403 404 struct counter_device *counter_alloc(size_t sizeof_priv); 405 void counter_put(struct counter_device *const counter); 406 int counter_add(struct counter_device *const counter); 407 408 void counter_unregister(struct counter_device *const counter); 409 struct counter_device *devm_counter_alloc(struct device *dev, 410 size_t sizeof_priv); 411 int devm_counter_add(struct device *dev, 412 struct counter_device *const counter); 413 void counter_push_event(struct counter_device *const counter, const u8 event, 414 const u8 channel); 415 416 #define COUNTER_COMP_DEVICE_U8(_name, _read, _write) \ 417 { \ 418 .type = COUNTER_COMP_U8, \ 419 .name = (_name), \ 420 .device_u8_read = (_read), \ 421 .device_u8_write = (_write), \ 422 } 423 #define COUNTER_COMP_COUNT_U8(_name, _read, _write) \ 424 { \ 425 .type = COUNTER_COMP_U8, \ 426 .name = (_name), \ 427 .count_u8_read = (_read), \ 428 .count_u8_write = (_write), \ 429 } 430 #define COUNTER_COMP_SIGNAL_U8(_name, _read, _write) \ 431 { \ 432 .type = COUNTER_COMP_U8, \ 433 .name = (_name), \ 434 .signal_u8_read = (_read), \ 435 .signal_u8_write = (_write), \ 436 } 437 438 #define COUNTER_COMP_DEVICE_U64(_name, _read, _write) \ 439 { \ 440 .type = COUNTER_COMP_U64, \ 441 .name = (_name), \ 442 .device_u64_read = (_read), \ 443 .device_u64_write = (_write), \ 444 } 445 #define COUNTER_COMP_COUNT_U64(_name, _read, _write) \ 446 { \ 447 .type = COUNTER_COMP_U64, \ 448 .name = (_name), \ 449 .count_u64_read = (_read), \ 450 .count_u64_write = (_write), \ 451 } 452 #define COUNTER_COMP_SIGNAL_U64(_name, _read, _write) \ 453 { \ 454 .type = COUNTER_COMP_U64, \ 455 .name = (_name), \ 456 .signal_u64_read = (_read), \ 457 .signal_u64_write = (_write), \ 458 } 459 460 #define COUNTER_COMP_DEVICE_BOOL(_name, _read, _write) \ 461 { \ 462 .type = COUNTER_COMP_BOOL, \ 463 .name = (_name), \ 464 .device_u8_read = (_read), \ 465 .device_u8_write = (_write), \ 466 } 467 #define COUNTER_COMP_COUNT_BOOL(_name, _read, _write) \ 468 { \ 469 .type = COUNTER_COMP_BOOL, \ 470 .name = (_name), \ 471 .count_u8_read = (_read), \ 472 .count_u8_write = (_write), \ 473 } 474 #define COUNTER_COMP_SIGNAL_BOOL(_name, _read, _write) \ 475 { \ 476 .type = COUNTER_COMP_BOOL, \ 477 .name = (_name), \ 478 .signal_u8_read = (_read), \ 479 .signal_u8_write = (_write), \ 480 } 481 482 struct counter_available { 483 union { 484 const u32 *enums; 485 const char *const *strs; 486 }; 487 size_t num_items; 488 }; 489 490 #define DEFINE_COUNTER_AVAILABLE(_name, _enums) \ 491 struct counter_available _name = { \ 492 .enums = (_enums), \ 493 .num_items = ARRAY_SIZE(_enums), \ 494 } 495 496 #define DEFINE_COUNTER_ENUM(_name, _strs) \ 497 struct counter_available _name = { \ 498 .strs = (_strs), \ 499 .num_items = ARRAY_SIZE(_strs), \ 500 } 501 502 #define COUNTER_COMP_DEVICE_ENUM(_name, _get, _set, _available) \ 503 { \ 504 .type = COUNTER_COMP_ENUM, \ 505 .name = (_name), \ 506 .device_u32_read = (_get), \ 507 .device_u32_write = (_set), \ 508 .priv = &(_available), \ 509 } 510 #define COUNTER_COMP_COUNT_ENUM(_name, _get, _set, _available) \ 511 { \ 512 .type = COUNTER_COMP_ENUM, \ 513 .name = (_name), \ 514 .count_u32_read = (_get), \ 515 .count_u32_write = (_set), \ 516 .priv = &(_available), \ 517 } 518 #define COUNTER_COMP_SIGNAL_ENUM(_name, _get, _set, _available) \ 519 { \ 520 .type = COUNTER_COMP_ENUM, \ 521 .name = (_name), \ 522 .signal_u32_read = (_get), \ 523 .signal_u32_write = (_set), \ 524 .priv = &(_available), \ 525 } 526 527 struct counter_array { 528 enum counter_comp_type type; 529 const struct counter_available *avail; 530 union { 531 size_t length; 532 size_t idx; 533 }; 534 }; 535 536 #define DEFINE_COUNTER_ARRAY_U64(_name, _length) \ 537 struct counter_array _name = { \ 538 .type = COUNTER_COMP_U64, \ 539 .length = (_length), \ 540 } 541 542 #define DEFINE_COUNTER_ARRAY_CAPTURE(_name, _length) \ 543 DEFINE_COUNTER_ARRAY_U64(_name, _length) 544 545 #define DEFINE_COUNTER_ARRAY_POLARITY(_name, _available, _length) \ 546 struct counter_array _name = { \ 547 .type = COUNTER_COMP_SIGNAL_POLARITY, \ 548 .avail = &(_available), \ 549 .length = (_length), \ 550 } 551 552 #define COUNTER_COMP_DEVICE_ARRAY_U64(_name, _read, _write, _array) \ 553 { \ 554 .type = COUNTER_COMP_ARRAY, \ 555 .name = (_name), \ 556 .device_array_u64_read = (_read), \ 557 .device_array_u64_write = (_write), \ 558 .priv = &(_array), \ 559 } 560 #define COUNTER_COMP_COUNT_ARRAY_U64(_name, _read, _write, _array) \ 561 { \ 562 .type = COUNTER_COMP_ARRAY, \ 563 .name = (_name), \ 564 .count_array_u64_read = (_read), \ 565 .count_array_u64_write = (_write), \ 566 .priv = &(_array), \ 567 } 568 #define COUNTER_COMP_SIGNAL_ARRAY_U64(_name, _read, _write, _array) \ 569 { \ 570 .type = COUNTER_COMP_ARRAY, \ 571 .name = (_name), \ 572 .signal_array_u64_read = (_read), \ 573 .signal_array_u64_write = (_write), \ 574 .priv = &(_array), \ 575 } 576 577 #define COUNTER_COMP_CAPTURE(_read, _write) \ 578 COUNTER_COMP_COUNT_U64("capture", _read, _write) 579 580 #define COUNTER_COMP_CEILING(_read, _write) \ 581 COUNTER_COMP_COUNT_U64("ceiling", _read, _write) 582 583 #define COUNTER_COMP_COUNT_MODE(_read, _write, _available) \ 584 { \ 585 .type = COUNTER_COMP_COUNT_MODE, \ 586 .name = "count_mode", \ 587 .count_u32_read = (_read), \ 588 .count_u32_write = (_write), \ 589 .priv = &(_available), \ 590 } 591 592 #define COUNTER_COMP_DIRECTION(_read) \ 593 { \ 594 .type = COUNTER_COMP_COUNT_DIRECTION, \ 595 .name = "direction", \ 596 .count_u32_read = (_read), \ 597 } 598 599 #define COUNTER_COMP_ENABLE(_read, _write) \ 600 COUNTER_COMP_COUNT_BOOL("enable", _read, _write) 601 602 #define COUNTER_COMP_FLOOR(_read, _write) \ 603 COUNTER_COMP_COUNT_U64("floor", _read, _write) 604 605 #define COUNTER_COMP_FREQUENCY(_read) \ 606 COUNTER_COMP_SIGNAL_U64("frequency", _read, NULL) 607 608 #define COUNTER_COMP_POLARITY(_read, _write, _available) \ 609 { \ 610 .type = COUNTER_COMP_SIGNAL_POLARITY, \ 611 .name = "polarity", \ 612 .signal_u32_read = (_read), \ 613 .signal_u32_write = (_write), \ 614 .priv = &(_available), \ 615 } 616 617 #define COUNTER_COMP_PRESET(_read, _write) \ 618 COUNTER_COMP_COUNT_U64("preset", _read, _write) 619 620 #define COUNTER_COMP_PRESET_ENABLE(_read, _write) \ 621 COUNTER_COMP_COUNT_BOOL("preset_enable", _read, _write) 622 623 #define COUNTER_COMP_ARRAY_CAPTURE(_read, _write, _array) \ 624 COUNTER_COMP_COUNT_ARRAY_U64("capture", _read, _write, _array) 625 626 #define COUNTER_COMP_ARRAY_POLARITY(_read, _write, _array) \ 627 { \ 628 .type = COUNTER_COMP_ARRAY, \ 629 .name = "polarity", \ 630 .signal_array_u32_read = (_read), \ 631 .signal_array_u32_write = (_write), \ 632 .priv = &(_array), \ 633 } 634 635 #endif /* _COUNTER_H_ */ 636