| /* SPDX-License-Identifier: GPL-2.0 */ |
| /* |
| * Counter interface |
| * Copyright (C) 2018 William Breathitt Gray |
| */ |
| #ifndef _COUNTER_H_ |
| #define _COUNTER_H_ |
| |
| #include <linux/device.h> |
| #include <linux/kernel.h> |
| #include <linux/types.h> |
| |
| struct counter_device; |
| struct counter_count; |
| struct counter_synapse; |
| struct counter_signal; |
| |
| enum counter_comp_type { |
| COUNTER_COMP_U8, |
| COUNTER_COMP_U64, |
| COUNTER_COMP_BOOL, |
| COUNTER_COMP_SIGNAL_LEVEL, |
| COUNTER_COMP_FUNCTION, |
| COUNTER_COMP_SYNAPSE_ACTION, |
| COUNTER_COMP_ENUM, |
| COUNTER_COMP_COUNT_DIRECTION, |
| COUNTER_COMP_COUNT_MODE, |
| }; |
| |
| enum counter_scope { |
| COUNTER_SCOPE_DEVICE, |
| COUNTER_SCOPE_SIGNAL, |
| COUNTER_SCOPE_COUNT, |
| }; |
| |
| enum counter_count_direction { |
| COUNTER_COUNT_DIRECTION_FORWARD, |
| COUNTER_COUNT_DIRECTION_BACKWARD, |
| }; |
| |
| enum counter_count_mode { |
| COUNTER_COUNT_MODE_NORMAL, |
| COUNTER_COUNT_MODE_RANGE_LIMIT, |
| COUNTER_COUNT_MODE_NON_RECYCLE, |
| COUNTER_COUNT_MODE_MODULO_N, |
| }; |
| |
| enum counter_function { |
| COUNTER_FUNCTION_INCREASE, |
| COUNTER_FUNCTION_DECREASE, |
| COUNTER_FUNCTION_PULSE_DIRECTION, |
| COUNTER_FUNCTION_QUADRATURE_X1_A, |
| COUNTER_FUNCTION_QUADRATURE_X1_B, |
| COUNTER_FUNCTION_QUADRATURE_X2_A, |
| COUNTER_FUNCTION_QUADRATURE_X2_B, |
| COUNTER_FUNCTION_QUADRATURE_X4, |
| }; |
| |
| enum counter_signal_level { |
| COUNTER_SIGNAL_LEVEL_LOW, |
| COUNTER_SIGNAL_LEVEL_HIGH, |
| }; |
| |
| enum counter_synapse_action { |
| COUNTER_SYNAPSE_ACTION_NONE, |
| COUNTER_SYNAPSE_ACTION_RISING_EDGE, |
| COUNTER_SYNAPSE_ACTION_FALLING_EDGE, |
| COUNTER_SYNAPSE_ACTION_BOTH_EDGES, |
| }; |
| |
| /** |
| * struct counter_comp - Counter component node |
| * @type: Counter component data type |
| * @name: device-specific component name |
| * @priv: component-relevant data |
| * @action_read: Synapse action mode read callback. The read value of the |
| * respective Synapse action mode should be passed back via |
| * the action parameter. |
| * @device_u8_read: Device u8 component read callback. The read value of the |
| * respective Device u8 component should be passed back via |
| * the val parameter. |
| * @count_u8_read: Count u8 component read callback. The read value of the |
| * respective Count u8 component should be passed back via |
| * the val parameter. |
| * @signal_u8_read: Signal u8 component read callback. The read value of the |
| * respective Signal u8 component should be passed back via |
| * the val parameter. |
| * @device_u32_read: Device u32 component read callback. The read value of |
| * the respective Device u32 component should be passed |
| * back via the val parameter. |
| * @count_u32_read: Count u32 component read callback. The read value of the |
| * respective Count u32 component should be passed back via |
| * the val parameter. |
| * @signal_u32_read: Signal u32 component read callback. The read value of |
| * the respective Signal u32 component should be passed |
| * back via the val parameter. |
| * @device_u64_read: Device u64 component read callback. The read value of |
| * the respective Device u64 component should be passed |
| * back via the val parameter. |
| * @count_u64_read: Count u64 component read callback. The read value of the |
| * respective Count u64 component should be passed back via |
| * the val parameter. |
| * @signal_u64_read: Signal u64 component read callback. The read value of |
| * the respective Signal u64 component should be passed |
| * back via the val parameter. |
| * @action_write: Synapse action mode write callback. The write value of |
| * the respective Synapse action mode is passed via the |
| * action parameter. |
| * @device_u8_write: Device u8 component write callback. The write value of |
| * the respective Device u8 component is passed via the val |
| * parameter. |
| * @count_u8_write: Count u8 component write callback. The write value of |
| * the respective Count u8 component is passed via the val |
| * parameter. |
| * @signal_u8_write: Signal u8 component write callback. The write value of |
| * the respective Signal u8 component is passed via the val |
| * parameter. |
| * @device_u32_write: Device u32 component write callback. The write value of |
| * the respective Device u32 component is passed via the |
| * val parameter. |
| * @count_u32_write: Count u32 component write callback. The write value of |
| * the respective Count u32 component is passed via the val |
| * parameter. |
| * @signal_u32_write: Signal u32 component write callback. The write value of |
| * the respective Signal u32 component is passed via the |
| * val parameter. |
| * @device_u64_write: Device u64 component write callback. The write value of |
| * the respective Device u64 component is passed via the |
| * val parameter. |
| * @count_u64_write: Count u64 component write callback. The write value of |
| * the respective Count u64 component is passed via the val |
| * parameter. |
| * @signal_u64_write: Signal u64 component write callback. The write value of |
| * the respective Signal u64 component is passed via the |
| * val parameter. |
| */ |
| struct counter_comp { |
| enum counter_comp_type type; |
| const char *name; |
| void *priv; |
| union { |
| int (*action_read)(struct counter_device *counter, |
| struct counter_count *count, |
| struct counter_synapse *synapse, |
| enum counter_synapse_action *action); |
| int (*device_u8_read)(struct counter_device *counter, u8 *val); |
| int (*count_u8_read)(struct counter_device *counter, |
| struct counter_count *count, u8 *val); |
| int (*signal_u8_read)(struct counter_device *counter, |
| struct counter_signal *signal, u8 *val); |
| int (*device_u32_read)(struct counter_device *counter, |
| u32 *val); |
| int (*count_u32_read)(struct counter_device *counter, |
| struct counter_count *count, u32 *val); |
| int (*signal_u32_read)(struct counter_device *counter, |
| struct counter_signal *signal, u32 *val); |
| int (*device_u64_read)(struct counter_device *counter, |
| u64 *val); |
| int (*count_u64_read)(struct counter_device *counter, |
| struct counter_count *count, u64 *val); |
| int (*signal_u64_read)(struct counter_device *counter, |
| struct counter_signal *signal, u64 *val); |
| }; |
| union { |
| int (*action_write)(struct counter_device *counter, |
| struct counter_count *count, |
| struct counter_synapse *synapse, |
| enum counter_synapse_action action); |
| int (*device_u8_write)(struct counter_device *counter, u8 val); |
| int (*count_u8_write)(struct counter_device *counter, |
| struct counter_count *count, u8 val); |
| int (*signal_u8_write)(struct counter_device *counter, |
| struct counter_signal *signal, u8 val); |
| int (*device_u32_write)(struct counter_device *counter, |
| u32 val); |
| int (*count_u32_write)(struct counter_device *counter, |
| struct counter_count *count, u32 val); |
| int (*signal_u32_write)(struct counter_device *counter, |
| struct counter_signal *signal, u32 val); |
| int (*device_u64_write)(struct counter_device *counter, |
| u64 val); |
| int (*count_u64_write)(struct counter_device *counter, |
| struct counter_count *count, u64 val); |
| int (*signal_u64_write)(struct counter_device *counter, |
| struct counter_signal *signal, u64 val); |
| }; |
| }; |
| |
| /** |
| * struct counter_signal - Counter Signal node |
| * @id: unique ID used to identify signal |
| * @name: device-specific Signal name; ideally, this should match the name |
| * as it appears in the datasheet documentation |
| * @ext: optional array of Counter Signal extensions |
| * @num_ext: number of Counter Signal extensions specified in @ext |
| */ |
| struct counter_signal { |
| int id; |
| const char *name; |
| |
| struct counter_comp *ext; |
| size_t num_ext; |
| }; |
| |
| /** |
| * struct counter_synapse - Counter Synapse node |
| * @actions_list: array of available action modes |
| * @num_actions: number of action modes specified in @actions_list |
| * @signal: pointer to associated signal |
| */ |
| struct counter_synapse { |
| const enum counter_synapse_action *actions_list; |
| size_t num_actions; |
| |
| struct counter_signal *signal; |
| }; |
| |
| /** |
| * struct counter_count - Counter Count node |
| * @id: unique ID used to identify Count |
| * @name: device-specific Count name; ideally, this should match |
| * the name as it appears in the datasheet documentation |
| * @functions_list: array available function modes |
| * @num_functions: number of function modes specified in @functions_list |
| * @synapses: array of synapses for initialization |
| * @num_synapses: number of synapses specified in @synapses |
| * @ext: optional array of Counter Count extensions |
| * @num_ext: number of Counter Count extensions specified in @ext |
| */ |
| struct counter_count { |
| int id; |
| const char *name; |
| |
| const enum counter_function *functions_list; |
| size_t num_functions; |
| |
| struct counter_synapse *synapses; |
| size_t num_synapses; |
| |
| struct counter_comp *ext; |
| size_t num_ext; |
| }; |
| |
| /** |
| * struct counter_ops - Callbacks from driver |
| * @signal_read: optional read callback for Signal attribute. The read |
| * level of the respective Signal should be passed back via |
| * the level parameter. |
| * @count_read: optional read callback for Count attribute. The read |
| * value of the respective Count should be passed back via |
| * the val parameter. |
| * @count_write: optional write callback for Count attribute. The write |
| * value for the respective Count is passed in via the val |
| * parameter. |
| * @function_read: read callback the Count function modes. The read |
| * function mode of the respective Count should be passed |
| * back via the function parameter. |
| * @function_write: write callback for Count function modes. The function |
| * mode to write for the respective Count is passed in via |
| * the function parameter. |
| * @action_read: read callback the Synapse action modes. The read action |
| * mode of the respective Synapse should be passed back via |
| * the action parameter. |
| * @action_write: write callback for Synapse action modes. The action mode |
| * to write for the respective Synapse is passed in via the |
| * action parameter. |
| */ |
| struct counter_ops { |
| int (*signal_read)(struct counter_device *counter, |
| struct counter_signal *signal, |
| enum counter_signal_level *level); |
| int (*count_read)(struct counter_device *counter, |
| struct counter_count *count, u64 *value); |
| int (*count_write)(struct counter_device *counter, |
| struct counter_count *count, u64 value); |
| int (*function_read)(struct counter_device *counter, |
| struct counter_count *count, |
| enum counter_function *function); |
| int (*function_write)(struct counter_device *counter, |
| struct counter_count *count, |
| enum counter_function function); |
| int (*action_read)(struct counter_device *counter, |
| struct counter_count *count, |
| struct counter_synapse *synapse, |
| enum counter_synapse_action *action); |
| int (*action_write)(struct counter_device *counter, |
| struct counter_count *count, |
| struct counter_synapse *synapse, |
| enum counter_synapse_action action); |
| }; |
| |
| /** |
| * struct counter_device - Counter data structure |
| * @name: name of the device as it appears in the datasheet |
| * @parent: optional parent device providing the counters |
| * @ops: callbacks from driver |
| * @signals: array of Signals |
| * @num_signals: number of Signals specified in @signals |
| * @counts: array of Counts |
| * @num_counts: number of Counts specified in @counts |
| * @ext: optional array of Counter device extensions |
| * @num_ext: number of Counter device extensions specified in @ext |
| * @priv: optional private data supplied by driver |
| * @dev: internal device structure |
| */ |
| struct counter_device { |
| const char *name; |
| struct device *parent; |
| |
| const struct counter_ops *ops; |
| |
| struct counter_signal *signals; |
| size_t num_signals; |
| struct counter_count *counts; |
| size_t num_counts; |
| |
| struct counter_comp *ext; |
| size_t num_ext; |
| |
| void *priv; |
| |
| struct device dev; |
| }; |
| |
| int counter_register(struct counter_device *const counter); |
| void counter_unregister(struct counter_device *const counter); |
| int devm_counter_register(struct device *dev, |
| struct counter_device *const counter); |
| |
| #define COUNTER_COMP_DEVICE_U8(_name, _read, _write) \ |
| { \ |
| .type = COUNTER_COMP_U8, \ |
| .name = (_name), \ |
| .device_u8_read = (_read), \ |
| .device_u8_write = (_write), \ |
| } |
| #define COUNTER_COMP_COUNT_U8(_name, _read, _write) \ |
| { \ |
| .type = COUNTER_COMP_U8, \ |
| .name = (_name), \ |
| .count_u8_read = (_read), \ |
| .count_u8_write = (_write), \ |
| } |
| #define COUNTER_COMP_SIGNAL_U8(_name, _read, _write) \ |
| { \ |
| .type = COUNTER_COMP_U8, \ |
| .name = (_name), \ |
| .signal_u8_read = (_read), \ |
| .signal_u8_write = (_write), \ |
| } |
| |
| #define COUNTER_COMP_DEVICE_U64(_name, _read, _write) \ |
| { \ |
| .type = COUNTER_COMP_U64, \ |
| .name = (_name), \ |
| .device_u64_read = (_read), \ |
| .device_u64_write = (_write), \ |
| } |
| #define COUNTER_COMP_COUNT_U64(_name, _read, _write) \ |
| { \ |
| .type = COUNTER_COMP_U64, \ |
| .name = (_name), \ |
| .count_u64_read = (_read), \ |
| .count_u64_write = (_write), \ |
| } |
| #define COUNTER_COMP_SIGNAL_U64(_name, _read, _write) \ |
| { \ |
| .type = COUNTER_COMP_U64, \ |
| .name = (_name), \ |
| .signal_u64_read = (_read), \ |
| .signal_u64_write = (_write), \ |
| } |
| |
| #define COUNTER_COMP_DEVICE_BOOL(_name, _read, _write) \ |
| { \ |
| .type = COUNTER_COMP_BOOL, \ |
| .name = (_name), \ |
| .device_u8_read = (_read), \ |
| .device_u8_write = (_write), \ |
| } |
| #define COUNTER_COMP_COUNT_BOOL(_name, _read, _write) \ |
| { \ |
| .type = COUNTER_COMP_BOOL, \ |
| .name = (_name), \ |
| .count_u8_read = (_read), \ |
| .count_u8_write = (_write), \ |
| } |
| #define COUNTER_COMP_SIGNAL_BOOL(_name, _read, _write) \ |
| { \ |
| .type = COUNTER_COMP_BOOL, \ |
| .name = (_name), \ |
| .signal_u8_read = (_read), \ |
| .signal_u8_write = (_write), \ |
| } |
| |
| struct counter_available { |
| union { |
| const u32 *enums; |
| const char *const *strs; |
| }; |
| size_t num_items; |
| }; |
| |
| #define DEFINE_COUNTER_AVAILABLE(_name, _enums) \ |
| struct counter_available _name = { \ |
| .enums = (_enums), \ |
| .num_items = ARRAY_SIZE(_enums), \ |
| } |
| |
| #define DEFINE_COUNTER_ENUM(_name, _strs) \ |
| struct counter_available _name = { \ |
| .strs = (_strs), \ |
| .num_items = ARRAY_SIZE(_strs), \ |
| } |
| |
| #define COUNTER_COMP_DEVICE_ENUM(_name, _get, _set, _available) \ |
| { \ |
| .type = COUNTER_COMP_ENUM, \ |
| .name = (_name), \ |
| .device_u32_read = (_get), \ |
| .device_u32_write = (_set), \ |
| .priv = &(_available), \ |
| } |
| #define COUNTER_COMP_COUNT_ENUM(_name, _get, _set, _available) \ |
| { \ |
| .type = COUNTER_COMP_ENUM, \ |
| .name = (_name), \ |
| .count_u32_read = (_get), \ |
| .count_u32_write = (_set), \ |
| .priv = &(_available), \ |
| } |
| #define COUNTER_COMP_SIGNAL_ENUM(_name, _get, _set, _available) \ |
| { \ |
| .type = COUNTER_COMP_ENUM, \ |
| .name = (_name), \ |
| .signal_u32_read = (_get), \ |
| .signal_u32_write = (_set), \ |
| .priv = &(_available), \ |
| } |
| |
| #define COUNTER_COMP_CEILING(_read, _write) \ |
| COUNTER_COMP_COUNT_U64("ceiling", _read, _write) |
| |
| #define COUNTER_COMP_COUNT_MODE(_read, _write, _available) \ |
| { \ |
| .type = COUNTER_COMP_COUNT_MODE, \ |
| .name = "count_mode", \ |
| .count_u32_read = (_read), \ |
| .count_u32_write = (_write), \ |
| .priv = &(_available), \ |
| } |
| |
| #define COUNTER_COMP_DIRECTION(_read) \ |
| { \ |
| .type = COUNTER_COMP_COUNT_DIRECTION, \ |
| .name = "direction", \ |
| .count_u32_read = (_read), \ |
| } |
| |
| #define COUNTER_COMP_ENABLE(_read, _write) \ |
| COUNTER_COMP_COUNT_BOOL("enable", _read, _write) |
| |
| #define COUNTER_COMP_FLOOR(_read, _write) \ |
| COUNTER_COMP_COUNT_U64("floor", _read, _write) |
| |
| #define COUNTER_COMP_PRESET(_read, _write) \ |
| COUNTER_COMP_COUNT_U64("preset", _read, _write) |
| |
| #define COUNTER_COMP_PRESET_ENABLE(_read, _write) \ |
| COUNTER_COMP_COUNT_BOOL("preset_enable", _read, _write) |
| |
| #endif /* _COUNTER_H_ */ |
