mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-24 09:50:04 +00:00
![William Breathitt Gray](/assets/img/avatar_default.png)
Exposes consumer library functions providing support for interfaces compatible with the venerable Intel 8254 Programmable Interval Timer (PIT). The Intel 8254 PIT first appeared in the early 1980s and was used initially in IBM PC compatibles. The popularity of the original Intel 825x family of chips led to many subsequent variants and clones of the interface in various chips and integrated circuits. Although still popular, interfaces compatible with the Intel 8254 PIT are nowdays typically found embedded in larger VLSI processing chips and FPGA components rather than as discrete ICs. A CONFIG_I8254 Kconfig option is introduced by this patch. Modules wanting access to these i8254 library functions should select this Kconfig option, and import the I8254 symbol namespace. Link: https://lore.kernel.org/r/f6fe32c2db9525d816ab1a01f45abad56c081652.1681665189.git.william.gray@linaro.org/ Signed-off-by: William Breathitt Gray <william.gray@linaro.org>
1176 lines
32 KiB
C
1176 lines
32 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Generic Counter sysfs interface
|
|
* Copyright (C) 2020 William Breathitt Gray
|
|
*/
|
|
#include <linux/counter.h>
|
|
#include <linux/device.h>
|
|
#include <linux/err.h>
|
|
#include <linux/gfp.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/kfifo.h>
|
|
#include <linux/kstrtox.h>
|
|
#include <linux/list.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/string.h>
|
|
#include <linux/sysfs.h>
|
|
#include <linux/types.h>
|
|
|
|
#include "counter-sysfs.h"
|
|
|
|
static inline struct counter_device *counter_from_dev(struct device *dev)
|
|
{
|
|
return container_of(dev, struct counter_device, dev);
|
|
}
|
|
|
|
/**
|
|
* struct counter_attribute - Counter sysfs attribute
|
|
* @dev_attr: device attribute for sysfs
|
|
* @l: node to add Counter attribute to attribute group list
|
|
* @comp: Counter component callbacks and data
|
|
* @scope: Counter scope of the attribute
|
|
* @parent: pointer to the parent component
|
|
*/
|
|
struct counter_attribute {
|
|
struct device_attribute dev_attr;
|
|
struct list_head l;
|
|
|
|
struct counter_comp comp;
|
|
enum counter_scope scope;
|
|
void *parent;
|
|
};
|
|
|
|
#define to_counter_attribute(_dev_attr) \
|
|
container_of(_dev_attr, struct counter_attribute, dev_attr)
|
|
|
|
/**
|
|
* struct counter_attribute_group - container for attribute group
|
|
* @name: name of the attribute group
|
|
* @attr_list: list to keep track of created attributes
|
|
* @num_attr: number of attributes
|
|
*/
|
|
struct counter_attribute_group {
|
|
const char *name;
|
|
struct list_head attr_list;
|
|
size_t num_attr;
|
|
};
|
|
|
|
static const char *const counter_function_str[] = {
|
|
[COUNTER_FUNCTION_INCREASE] = "increase",
|
|
[COUNTER_FUNCTION_DECREASE] = "decrease",
|
|
[COUNTER_FUNCTION_PULSE_DIRECTION] = "pulse-direction",
|
|
[COUNTER_FUNCTION_QUADRATURE_X1_A] = "quadrature x1 a",
|
|
[COUNTER_FUNCTION_QUADRATURE_X1_B] = "quadrature x1 b",
|
|
[COUNTER_FUNCTION_QUADRATURE_X2_A] = "quadrature x2 a",
|
|
[COUNTER_FUNCTION_QUADRATURE_X2_B] = "quadrature x2 b",
|
|
[COUNTER_FUNCTION_QUADRATURE_X4] = "quadrature x4"
|
|
};
|
|
|
|
static const char *const counter_signal_value_str[] = {
|
|
[COUNTER_SIGNAL_LEVEL_LOW] = "low",
|
|
[COUNTER_SIGNAL_LEVEL_HIGH] = "high"
|
|
};
|
|
|
|
static const char *const counter_synapse_action_str[] = {
|
|
[COUNTER_SYNAPSE_ACTION_NONE] = "none",
|
|
[COUNTER_SYNAPSE_ACTION_RISING_EDGE] = "rising edge",
|
|
[COUNTER_SYNAPSE_ACTION_FALLING_EDGE] = "falling edge",
|
|
[COUNTER_SYNAPSE_ACTION_BOTH_EDGES] = "both edges"
|
|
};
|
|
|
|
static const char *const counter_count_direction_str[] = {
|
|
[COUNTER_COUNT_DIRECTION_FORWARD] = "forward",
|
|
[COUNTER_COUNT_DIRECTION_BACKWARD] = "backward"
|
|
};
|
|
|
|
static const char *const counter_count_mode_str[] = {
|
|
[COUNTER_COUNT_MODE_NORMAL] = "normal",
|
|
[COUNTER_COUNT_MODE_RANGE_LIMIT] = "range limit",
|
|
[COUNTER_COUNT_MODE_NON_RECYCLE] = "non-recycle",
|
|
[COUNTER_COUNT_MODE_MODULO_N] = "modulo-n",
|
|
[COUNTER_COUNT_MODE_INTERRUPT_ON_TERMINAL_COUNT] = "interrupt on terminal count",
|
|
[COUNTER_COUNT_MODE_HARDWARE_RETRIGGERABLE_ONESHOT] = "hardware retriggerable one-shot",
|
|
[COUNTER_COUNT_MODE_RATE_GENERATOR] = "rate generator",
|
|
[COUNTER_COUNT_MODE_SQUARE_WAVE_MODE] = "square wave mode",
|
|
[COUNTER_COUNT_MODE_SOFTWARE_TRIGGERED_STROBE] = "software triggered strobe",
|
|
[COUNTER_COUNT_MODE_HARDWARE_TRIGGERED_STROBE] = "hardware triggered strobe",
|
|
};
|
|
|
|
static const char *const counter_signal_polarity_str[] = {
|
|
[COUNTER_SIGNAL_POLARITY_POSITIVE] = "positive",
|
|
[COUNTER_SIGNAL_POLARITY_NEGATIVE] = "negative"
|
|
};
|
|
|
|
static ssize_t counter_comp_u8_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
const struct counter_attribute *const a = to_counter_attribute(attr);
|
|
struct counter_device *const counter = counter_from_dev(dev);
|
|
int err;
|
|
u8 data = 0;
|
|
|
|
switch (a->scope) {
|
|
case COUNTER_SCOPE_DEVICE:
|
|
err = a->comp.device_u8_read(counter, &data);
|
|
break;
|
|
case COUNTER_SCOPE_SIGNAL:
|
|
err = a->comp.signal_u8_read(counter, a->parent, &data);
|
|
break;
|
|
case COUNTER_SCOPE_COUNT:
|
|
err = a->comp.count_u8_read(counter, a->parent, &data);
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
if (err < 0)
|
|
return err;
|
|
|
|
if (a->comp.type == COUNTER_COMP_BOOL)
|
|
/* data should already be boolean but ensure just to be safe */
|
|
data = !!data;
|
|
|
|
return sysfs_emit(buf, "%u\n", (unsigned int)data);
|
|
}
|
|
|
|
static ssize_t counter_comp_u8_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t len)
|
|
{
|
|
const struct counter_attribute *const a = to_counter_attribute(attr);
|
|
struct counter_device *const counter = counter_from_dev(dev);
|
|
int err;
|
|
bool bool_data = 0;
|
|
u8 data = 0;
|
|
|
|
if (a->comp.type == COUNTER_COMP_BOOL) {
|
|
err = kstrtobool(buf, &bool_data);
|
|
data = bool_data;
|
|
} else
|
|
err = kstrtou8(buf, 0, &data);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
switch (a->scope) {
|
|
case COUNTER_SCOPE_DEVICE:
|
|
err = a->comp.device_u8_write(counter, data);
|
|
break;
|
|
case COUNTER_SCOPE_SIGNAL:
|
|
err = a->comp.signal_u8_write(counter, a->parent, data);
|
|
break;
|
|
case COUNTER_SCOPE_COUNT:
|
|
err = a->comp.count_u8_write(counter, a->parent, data);
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return len;
|
|
}
|
|
|
|
static ssize_t counter_comp_u32_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
const struct counter_attribute *const a = to_counter_attribute(attr);
|
|
struct counter_device *const counter = counter_from_dev(dev);
|
|
const struct counter_available *const avail = a->comp.priv;
|
|
int err;
|
|
u32 data = 0;
|
|
|
|
switch (a->scope) {
|
|
case COUNTER_SCOPE_DEVICE:
|
|
err = a->comp.device_u32_read(counter, &data);
|
|
break;
|
|
case COUNTER_SCOPE_SIGNAL:
|
|
err = a->comp.signal_u32_read(counter, a->parent, &data);
|
|
break;
|
|
case COUNTER_SCOPE_COUNT:
|
|
if (a->comp.type == COUNTER_COMP_SYNAPSE_ACTION)
|
|
err = a->comp.action_read(counter, a->parent,
|
|
a->comp.priv, &data);
|
|
else
|
|
err = a->comp.count_u32_read(counter, a->parent, &data);
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
if (err < 0)
|
|
return err;
|
|
|
|
switch (a->comp.type) {
|
|
case COUNTER_COMP_FUNCTION:
|
|
return sysfs_emit(buf, "%s\n", counter_function_str[data]);
|
|
case COUNTER_COMP_SIGNAL_LEVEL:
|
|
return sysfs_emit(buf, "%s\n", counter_signal_value_str[data]);
|
|
case COUNTER_COMP_SYNAPSE_ACTION:
|
|
return sysfs_emit(buf, "%s\n", counter_synapse_action_str[data]);
|
|
case COUNTER_COMP_ENUM:
|
|
return sysfs_emit(buf, "%s\n", avail->strs[data]);
|
|
case COUNTER_COMP_COUNT_DIRECTION:
|
|
return sysfs_emit(buf, "%s\n", counter_count_direction_str[data]);
|
|
case COUNTER_COMP_COUNT_MODE:
|
|
return sysfs_emit(buf, "%s\n", counter_count_mode_str[data]);
|
|
case COUNTER_COMP_SIGNAL_POLARITY:
|
|
return sysfs_emit(buf, "%s\n", counter_signal_polarity_str[data]);
|
|
default:
|
|
return sysfs_emit(buf, "%u\n", (unsigned int)data);
|
|
}
|
|
}
|
|
|
|
static int counter_find_enum(u32 *const enum_item, const u32 *const enums,
|
|
const size_t num_enums, const char *const buf,
|
|
const char *const string_array[])
|
|
{
|
|
size_t index;
|
|
|
|
for (index = 0; index < num_enums; index++) {
|
|
*enum_item = enums[index];
|
|
if (sysfs_streq(buf, string_array[*enum_item]))
|
|
return 0;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static ssize_t counter_comp_u32_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t len)
|
|
{
|
|
const struct counter_attribute *const a = to_counter_attribute(attr);
|
|
struct counter_device *const counter = counter_from_dev(dev);
|
|
struct counter_count *const count = a->parent;
|
|
struct counter_synapse *const synapse = a->comp.priv;
|
|
const struct counter_available *const avail = a->comp.priv;
|
|
int err;
|
|
u32 data = 0;
|
|
|
|
switch (a->comp.type) {
|
|
case COUNTER_COMP_FUNCTION:
|
|
err = counter_find_enum(&data, count->functions_list,
|
|
count->num_functions, buf,
|
|
counter_function_str);
|
|
break;
|
|
case COUNTER_COMP_SYNAPSE_ACTION:
|
|
err = counter_find_enum(&data, synapse->actions_list,
|
|
synapse->num_actions, buf,
|
|
counter_synapse_action_str);
|
|
break;
|
|
case COUNTER_COMP_ENUM:
|
|
err = __sysfs_match_string(avail->strs, avail->num_items, buf);
|
|
data = err;
|
|
break;
|
|
case COUNTER_COMP_COUNT_MODE:
|
|
err = counter_find_enum(&data, avail->enums, avail->num_items,
|
|
buf, counter_count_mode_str);
|
|
break;
|
|
case COUNTER_COMP_SIGNAL_POLARITY:
|
|
err = counter_find_enum(&data, avail->enums, avail->num_items,
|
|
buf, counter_signal_polarity_str);
|
|
break;
|
|
default:
|
|
err = kstrtou32(buf, 0, &data);
|
|
break;
|
|
}
|
|
if (err < 0)
|
|
return err;
|
|
|
|
switch (a->scope) {
|
|
case COUNTER_SCOPE_DEVICE:
|
|
err = a->comp.device_u32_write(counter, data);
|
|
break;
|
|
case COUNTER_SCOPE_SIGNAL:
|
|
err = a->comp.signal_u32_write(counter, a->parent, data);
|
|
break;
|
|
case COUNTER_SCOPE_COUNT:
|
|
if (a->comp.type == COUNTER_COMP_SYNAPSE_ACTION)
|
|
err = a->comp.action_write(counter, count, synapse,
|
|
data);
|
|
else
|
|
err = a->comp.count_u32_write(counter, count, data);
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return len;
|
|
}
|
|
|
|
static ssize_t counter_comp_u64_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
const struct counter_attribute *const a = to_counter_attribute(attr);
|
|
struct counter_device *const counter = counter_from_dev(dev);
|
|
int err;
|
|
u64 data = 0;
|
|
|
|
switch (a->scope) {
|
|
case COUNTER_SCOPE_DEVICE:
|
|
err = a->comp.device_u64_read(counter, &data);
|
|
break;
|
|
case COUNTER_SCOPE_SIGNAL:
|
|
err = a->comp.signal_u64_read(counter, a->parent, &data);
|
|
break;
|
|
case COUNTER_SCOPE_COUNT:
|
|
err = a->comp.count_u64_read(counter, a->parent, &data);
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return sysfs_emit(buf, "%llu\n", (unsigned long long)data);
|
|
}
|
|
|
|
static ssize_t counter_comp_u64_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t len)
|
|
{
|
|
const struct counter_attribute *const a = to_counter_attribute(attr);
|
|
struct counter_device *const counter = counter_from_dev(dev);
|
|
int err;
|
|
u64 data = 0;
|
|
|
|
err = kstrtou64(buf, 0, &data);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
switch (a->scope) {
|
|
case COUNTER_SCOPE_DEVICE:
|
|
err = a->comp.device_u64_write(counter, data);
|
|
break;
|
|
case COUNTER_SCOPE_SIGNAL:
|
|
err = a->comp.signal_u64_write(counter, a->parent, data);
|
|
break;
|
|
case COUNTER_SCOPE_COUNT:
|
|
err = a->comp.count_u64_write(counter, a->parent, data);
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return len;
|
|
}
|
|
|
|
static ssize_t counter_comp_array_u32_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
const struct counter_attribute *const a = to_counter_attribute(attr);
|
|
struct counter_device *const counter = counter_from_dev(dev);
|
|
const struct counter_array *const element = a->comp.priv;
|
|
int err;
|
|
u32 data = 0;
|
|
|
|
if (a->scope != COUNTER_SCOPE_SIGNAL ||
|
|
element->type != COUNTER_COMP_SIGNAL_POLARITY)
|
|
return -EINVAL;
|
|
|
|
err = a->comp.signal_array_u32_read(counter, a->parent, element->idx,
|
|
&data);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return sysfs_emit(buf, "%s\n", counter_signal_polarity_str[data]);
|
|
}
|
|
|
|
static ssize_t counter_comp_array_u32_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t len)
|
|
{
|
|
const struct counter_attribute *const a = to_counter_attribute(attr);
|
|
struct counter_device *const counter = counter_from_dev(dev);
|
|
const struct counter_array *const element = a->comp.priv;
|
|
int err;
|
|
u32 data = 0;
|
|
|
|
if (element->type != COUNTER_COMP_SIGNAL_POLARITY ||
|
|
a->scope != COUNTER_SCOPE_SIGNAL)
|
|
return -EINVAL;
|
|
|
|
err = counter_find_enum(&data, element->avail->enums,
|
|
element->avail->num_items, buf,
|
|
counter_signal_polarity_str);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
err = a->comp.signal_array_u32_write(counter, a->parent, element->idx,
|
|
data);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return len;
|
|
}
|
|
|
|
static ssize_t counter_comp_array_u64_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
const struct counter_attribute *const a = to_counter_attribute(attr);
|
|
struct counter_device *const counter = counter_from_dev(dev);
|
|
const struct counter_array *const element = a->comp.priv;
|
|
int err;
|
|
u64 data = 0;
|
|
|
|
switch (a->scope) {
|
|
case COUNTER_SCOPE_DEVICE:
|
|
err = a->comp.device_array_u64_read(counter, element->idx,
|
|
&data);
|
|
break;
|
|
case COUNTER_SCOPE_SIGNAL:
|
|
err = a->comp.signal_array_u64_read(counter, a->parent,
|
|
element->idx, &data);
|
|
break;
|
|
case COUNTER_SCOPE_COUNT:
|
|
err = a->comp.count_array_u64_read(counter, a->parent,
|
|
element->idx, &data);
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return sysfs_emit(buf, "%llu\n", (unsigned long long)data);
|
|
}
|
|
|
|
static ssize_t counter_comp_array_u64_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t len)
|
|
{
|
|
const struct counter_attribute *const a = to_counter_attribute(attr);
|
|
struct counter_device *const counter = counter_from_dev(dev);
|
|
const struct counter_array *const element = a->comp.priv;
|
|
int err;
|
|
u64 data = 0;
|
|
|
|
err = kstrtou64(buf, 0, &data);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
switch (a->scope) {
|
|
case COUNTER_SCOPE_DEVICE:
|
|
err = a->comp.device_array_u64_write(counter, element->idx,
|
|
data);
|
|
break;
|
|
case COUNTER_SCOPE_SIGNAL:
|
|
err = a->comp.signal_array_u64_write(counter, a->parent,
|
|
element->idx, data);
|
|
break;
|
|
case COUNTER_SCOPE_COUNT:
|
|
err = a->comp.count_array_u64_write(counter, a->parent,
|
|
element->idx, data);
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return len;
|
|
}
|
|
|
|
static ssize_t enums_available_show(const u32 *const enums,
|
|
const size_t num_enums,
|
|
const char *const strs[], char *buf)
|
|
{
|
|
size_t len = 0;
|
|
size_t index;
|
|
|
|
for (index = 0; index < num_enums; index++)
|
|
len += sysfs_emit_at(buf, len, "%s\n", strs[enums[index]]);
|
|
|
|
return len;
|
|
}
|
|
|
|
static ssize_t strs_available_show(const struct counter_available *const avail,
|
|
char *buf)
|
|
{
|
|
size_t len = 0;
|
|
size_t index;
|
|
|
|
for (index = 0; index < avail->num_items; index++)
|
|
len += sysfs_emit_at(buf, len, "%s\n", avail->strs[index]);
|
|
|
|
return len;
|
|
}
|
|
|
|
static ssize_t counter_comp_available_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
const struct counter_attribute *const a = to_counter_attribute(attr);
|
|
const struct counter_count *const count = a->parent;
|
|
const struct counter_synapse *const synapse = a->comp.priv;
|
|
const struct counter_available *const avail = a->comp.priv;
|
|
|
|
switch (a->comp.type) {
|
|
case COUNTER_COMP_FUNCTION:
|
|
return enums_available_show(count->functions_list,
|
|
count->num_functions,
|
|
counter_function_str, buf);
|
|
case COUNTER_COMP_SYNAPSE_ACTION:
|
|
return enums_available_show(synapse->actions_list,
|
|
synapse->num_actions,
|
|
counter_synapse_action_str, buf);
|
|
case COUNTER_COMP_ENUM:
|
|
return strs_available_show(avail, buf);
|
|
case COUNTER_COMP_COUNT_MODE:
|
|
return enums_available_show(avail->enums, avail->num_items,
|
|
counter_count_mode_str, buf);
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
static int counter_avail_attr_create(struct device *const dev,
|
|
struct counter_attribute_group *const group,
|
|
const struct counter_comp *const comp, void *const parent)
|
|
{
|
|
struct counter_attribute *counter_attr;
|
|
struct device_attribute *dev_attr;
|
|
|
|
counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL);
|
|
if (!counter_attr)
|
|
return -ENOMEM;
|
|
|
|
/* Configure Counter attribute */
|
|
counter_attr->comp.type = comp->type;
|
|
counter_attr->comp.priv = comp->priv;
|
|
counter_attr->parent = parent;
|
|
|
|
/* Initialize sysfs attribute */
|
|
dev_attr = &counter_attr->dev_attr;
|
|
sysfs_attr_init(&dev_attr->attr);
|
|
|
|
/* Configure device attribute */
|
|
dev_attr->attr.name = devm_kasprintf(dev, GFP_KERNEL, "%s_available",
|
|
comp->name);
|
|
if (!dev_attr->attr.name)
|
|
return -ENOMEM;
|
|
dev_attr->attr.mode = 0444;
|
|
dev_attr->show = counter_comp_available_show;
|
|
|
|
/* Store list node */
|
|
list_add(&counter_attr->l, &group->attr_list);
|
|
group->num_attr++;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int counter_attr_create(struct device *const dev,
|
|
struct counter_attribute_group *const group,
|
|
const struct counter_comp *const comp,
|
|
const enum counter_scope scope,
|
|
void *const parent)
|
|
{
|
|
const struct counter_array *const array = comp->priv;
|
|
struct counter_attribute *counter_attr;
|
|
struct device_attribute *dev_attr;
|
|
|
|
counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL);
|
|
if (!counter_attr)
|
|
return -ENOMEM;
|
|
|
|
/* Configure Counter attribute */
|
|
counter_attr->comp = *comp;
|
|
counter_attr->scope = scope;
|
|
counter_attr->parent = parent;
|
|
|
|
/* Configure device attribute */
|
|
dev_attr = &counter_attr->dev_attr;
|
|
sysfs_attr_init(&dev_attr->attr);
|
|
dev_attr->attr.name = comp->name;
|
|
switch (comp->type) {
|
|
case COUNTER_COMP_U8:
|
|
case COUNTER_COMP_BOOL:
|
|
if (comp->device_u8_read) {
|
|
dev_attr->attr.mode |= 0444;
|
|
dev_attr->show = counter_comp_u8_show;
|
|
}
|
|
if (comp->device_u8_write) {
|
|
dev_attr->attr.mode |= 0200;
|
|
dev_attr->store = counter_comp_u8_store;
|
|
}
|
|
break;
|
|
case COUNTER_COMP_SIGNAL_LEVEL:
|
|
case COUNTER_COMP_FUNCTION:
|
|
case COUNTER_COMP_SYNAPSE_ACTION:
|
|
case COUNTER_COMP_ENUM:
|
|
case COUNTER_COMP_COUNT_DIRECTION:
|
|
case COUNTER_COMP_COUNT_MODE:
|
|
case COUNTER_COMP_SIGNAL_POLARITY:
|
|
if (comp->device_u32_read) {
|
|
dev_attr->attr.mode |= 0444;
|
|
dev_attr->show = counter_comp_u32_show;
|
|
}
|
|
if (comp->device_u32_write) {
|
|
dev_attr->attr.mode |= 0200;
|
|
dev_attr->store = counter_comp_u32_store;
|
|
}
|
|
break;
|
|
case COUNTER_COMP_U64:
|
|
if (comp->device_u64_read) {
|
|
dev_attr->attr.mode |= 0444;
|
|
dev_attr->show = counter_comp_u64_show;
|
|
}
|
|
if (comp->device_u64_write) {
|
|
dev_attr->attr.mode |= 0200;
|
|
dev_attr->store = counter_comp_u64_store;
|
|
}
|
|
break;
|
|
case COUNTER_COMP_ARRAY:
|
|
switch (array->type) {
|
|
case COUNTER_COMP_SIGNAL_POLARITY:
|
|
if (comp->signal_array_u32_read) {
|
|
dev_attr->attr.mode |= 0444;
|
|
dev_attr->show = counter_comp_array_u32_show;
|
|
}
|
|
if (comp->signal_array_u32_write) {
|
|
dev_attr->attr.mode |= 0200;
|
|
dev_attr->store = counter_comp_array_u32_store;
|
|
}
|
|
break;
|
|
case COUNTER_COMP_U64:
|
|
if (comp->device_array_u64_read) {
|
|
dev_attr->attr.mode |= 0444;
|
|
dev_attr->show = counter_comp_array_u64_show;
|
|
}
|
|
if (comp->device_array_u64_write) {
|
|
dev_attr->attr.mode |= 0200;
|
|
dev_attr->store = counter_comp_array_u64_store;
|
|
}
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Store list node */
|
|
list_add(&counter_attr->l, &group->attr_list);
|
|
group->num_attr++;
|
|
|
|
/* Create "*_available" attribute if needed */
|
|
switch (comp->type) {
|
|
case COUNTER_COMP_FUNCTION:
|
|
case COUNTER_COMP_SYNAPSE_ACTION:
|
|
case COUNTER_COMP_ENUM:
|
|
case COUNTER_COMP_COUNT_MODE:
|
|
return counter_avail_attr_create(dev, group, comp, parent);
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static ssize_t counter_comp_name_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
return sysfs_emit(buf, "%s\n", to_counter_attribute(attr)->comp.name);
|
|
}
|
|
|
|
static int counter_name_attr_create(struct device *const dev,
|
|
struct counter_attribute_group *const group,
|
|
const char *const name)
|
|
{
|
|
struct counter_attribute *counter_attr;
|
|
|
|
counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL);
|
|
if (!counter_attr)
|
|
return -ENOMEM;
|
|
|
|
/* Configure Counter attribute */
|
|
counter_attr->comp.name = name;
|
|
|
|
/* Configure device attribute */
|
|
sysfs_attr_init(&counter_attr->dev_attr.attr);
|
|
counter_attr->dev_attr.attr.name = "name";
|
|
counter_attr->dev_attr.attr.mode = 0444;
|
|
counter_attr->dev_attr.show = counter_comp_name_show;
|
|
|
|
/* Store list node */
|
|
list_add(&counter_attr->l, &group->attr_list);
|
|
group->num_attr++;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t counter_comp_id_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
const size_t id = (size_t)to_counter_attribute(attr)->comp.priv;
|
|
|
|
return sysfs_emit(buf, "%zu\n", id);
|
|
}
|
|
|
|
static int counter_comp_id_attr_create(struct device *const dev,
|
|
struct counter_attribute_group *const group,
|
|
const char *name, const size_t id)
|
|
{
|
|
struct counter_attribute *counter_attr;
|
|
|
|
/* Allocate Counter attribute */
|
|
counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL);
|
|
if (!counter_attr)
|
|
return -ENOMEM;
|
|
|
|
/* Generate component ID name */
|
|
name = devm_kasprintf(dev, GFP_KERNEL, "%s_component_id", name);
|
|
if (!name)
|
|
return -ENOMEM;
|
|
|
|
/* Configure Counter attribute */
|
|
counter_attr->comp.priv = (void *)id;
|
|
|
|
/* Configure device attribute */
|
|
sysfs_attr_init(&counter_attr->dev_attr.attr);
|
|
counter_attr->dev_attr.attr.name = name;
|
|
counter_attr->dev_attr.attr.mode = 0444;
|
|
counter_attr->dev_attr.show = counter_comp_id_show;
|
|
|
|
/* Store list node */
|
|
list_add(&counter_attr->l, &group->attr_list);
|
|
group->num_attr++;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int counter_ext_attrs_create(struct device *const dev,
|
|
struct counter_attribute_group *const group,
|
|
const struct counter_comp *const ext,
|
|
const enum counter_scope scope,
|
|
void *const parent, const size_t id)
|
|
{
|
|
int err;
|
|
|
|
/* Create main extension attribute */
|
|
err = counter_attr_create(dev, group, ext, scope, parent);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Create extension id attribute */
|
|
return counter_comp_id_attr_create(dev, group, ext->name, id);
|
|
}
|
|
|
|
static int counter_array_attrs_create(struct device *const dev,
|
|
struct counter_attribute_group *const group,
|
|
const struct counter_comp *const comp,
|
|
const enum counter_scope scope,
|
|
void *const parent, const size_t id)
|
|
{
|
|
const struct counter_array *const array = comp->priv;
|
|
struct counter_comp ext = *comp;
|
|
struct counter_array *element;
|
|
size_t idx;
|
|
int err;
|
|
|
|
/* Create an attribute for each array element */
|
|
for (idx = 0; idx < array->length; idx++) {
|
|
/* Generate array element attribute name */
|
|
ext.name = devm_kasprintf(dev, GFP_KERNEL, "%s%zu", comp->name,
|
|
idx);
|
|
if (!ext.name)
|
|
return -ENOMEM;
|
|
|
|
/* Allocate and configure array element */
|
|
element = devm_kzalloc(dev, sizeof(*element), GFP_KERNEL);
|
|
if (!element)
|
|
return -ENOMEM;
|
|
element->type = array->type;
|
|
element->avail = array->avail;
|
|
element->idx = idx;
|
|
ext.priv = element;
|
|
|
|
/* Create all attributes associated with the array element */
|
|
err = counter_ext_attrs_create(dev, group, &ext, scope, parent,
|
|
id + idx);
|
|
if (err < 0)
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int counter_sysfs_exts_add(struct device *const dev,
|
|
struct counter_attribute_group *const group,
|
|
const struct counter_comp *const exts,
|
|
const size_t num_ext,
|
|
const enum counter_scope scope,
|
|
void *const parent)
|
|
{
|
|
size_t i;
|
|
const struct counter_comp *ext;
|
|
int err;
|
|
size_t id = 0;
|
|
const struct counter_array *array;
|
|
|
|
/* Create attributes for each extension */
|
|
for (i = 0; i < num_ext; i++) {
|
|
ext = &exts[i];
|
|
if (ext->type == COUNTER_COMP_ARRAY) {
|
|
err = counter_array_attrs_create(dev, group, ext, scope,
|
|
parent, id);
|
|
array = ext->priv;
|
|
id += array->length;
|
|
} else {
|
|
err = counter_ext_attrs_create(dev, group, ext, scope,
|
|
parent, id);
|
|
id++;
|
|
}
|
|
if (err < 0)
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct counter_comp counter_signal_comp = {
|
|
.type = COUNTER_COMP_SIGNAL_LEVEL,
|
|
.name = "signal",
|
|
};
|
|
|
|
static int counter_signal_attrs_create(struct counter_device *const counter,
|
|
struct counter_attribute_group *const cattr_group,
|
|
struct counter_signal *const signal)
|
|
{
|
|
const enum counter_scope scope = COUNTER_SCOPE_SIGNAL;
|
|
struct device *const dev = &counter->dev;
|
|
int err;
|
|
struct counter_comp comp;
|
|
|
|
/* Create main Signal attribute */
|
|
comp = counter_signal_comp;
|
|
comp.signal_u32_read = counter->ops->signal_read;
|
|
err = counter_attr_create(dev, cattr_group, &comp, scope, signal);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Create Signal name attribute */
|
|
err = counter_name_attr_create(dev, cattr_group, signal->name);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Add Signal extensions */
|
|
return counter_sysfs_exts_add(dev, cattr_group, signal->ext,
|
|
signal->num_ext, scope, signal);
|
|
}
|
|
|
|
static int counter_sysfs_signals_add(struct counter_device *const counter,
|
|
struct counter_attribute_group *const groups)
|
|
{
|
|
size_t i;
|
|
int err;
|
|
|
|
/* Add each Signal */
|
|
for (i = 0; i < counter->num_signals; i++) {
|
|
/* Generate Signal attribute directory name */
|
|
groups[i].name = devm_kasprintf(&counter->dev, GFP_KERNEL,
|
|
"signal%zu", i);
|
|
if (!groups[i].name)
|
|
return -ENOMEM;
|
|
|
|
/* Create all attributes associated with Signal */
|
|
err = counter_signal_attrs_create(counter, groups + i,
|
|
counter->signals + i);
|
|
if (err < 0)
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int counter_sysfs_synapses_add(struct counter_device *const counter,
|
|
struct counter_attribute_group *const group,
|
|
struct counter_count *const count)
|
|
{
|
|
size_t i;
|
|
|
|
/* Add each Synapse */
|
|
for (i = 0; i < count->num_synapses; i++) {
|
|
struct device *const dev = &counter->dev;
|
|
struct counter_synapse *synapse;
|
|
size_t id;
|
|
struct counter_comp comp;
|
|
int err;
|
|
|
|
synapse = count->synapses + i;
|
|
|
|
/* Generate Synapse action name */
|
|
id = synapse->signal - counter->signals;
|
|
comp.name = devm_kasprintf(dev, GFP_KERNEL, "signal%zu_action",
|
|
id);
|
|
if (!comp.name)
|
|
return -ENOMEM;
|
|
|
|
/* Create action attribute */
|
|
comp.type = COUNTER_COMP_SYNAPSE_ACTION;
|
|
comp.action_read = counter->ops->action_read;
|
|
comp.action_write = counter->ops->action_write;
|
|
comp.priv = synapse;
|
|
err = counter_attr_create(dev, group, &comp,
|
|
COUNTER_SCOPE_COUNT, count);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Create Synapse component ID attribute */
|
|
err = counter_comp_id_attr_create(dev, group, comp.name, i);
|
|
if (err < 0)
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct counter_comp counter_count_comp =
|
|
COUNTER_COMP_COUNT_U64("count", NULL, NULL);
|
|
|
|
static struct counter_comp counter_function_comp = {
|
|
.type = COUNTER_COMP_FUNCTION,
|
|
.name = "function",
|
|
};
|
|
|
|
static int counter_count_attrs_create(struct counter_device *const counter,
|
|
struct counter_attribute_group *const cattr_group,
|
|
struct counter_count *const count)
|
|
{
|
|
const enum counter_scope scope = COUNTER_SCOPE_COUNT;
|
|
struct device *const dev = &counter->dev;
|
|
int err;
|
|
struct counter_comp comp;
|
|
|
|
/* Create main Count attribute */
|
|
comp = counter_count_comp;
|
|
comp.count_u64_read = counter->ops->count_read;
|
|
comp.count_u64_write = counter->ops->count_write;
|
|
err = counter_attr_create(dev, cattr_group, &comp, scope, count);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Create Count name attribute */
|
|
err = counter_name_attr_create(dev, cattr_group, count->name);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Create Count function attribute */
|
|
comp = counter_function_comp;
|
|
comp.count_u32_read = counter->ops->function_read;
|
|
comp.count_u32_write = counter->ops->function_write;
|
|
err = counter_attr_create(dev, cattr_group, &comp, scope, count);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Add Count extensions */
|
|
return counter_sysfs_exts_add(dev, cattr_group, count->ext,
|
|
count->num_ext, scope, count);
|
|
}
|
|
|
|
static int counter_sysfs_counts_add(struct counter_device *const counter,
|
|
struct counter_attribute_group *const groups)
|
|
{
|
|
size_t i;
|
|
struct counter_count *count;
|
|
int err;
|
|
|
|
/* Add each Count */
|
|
for (i = 0; i < counter->num_counts; i++) {
|
|
count = counter->counts + i;
|
|
|
|
/* Generate Count attribute directory name */
|
|
groups[i].name = devm_kasprintf(&counter->dev, GFP_KERNEL,
|
|
"count%zu", i);
|
|
if (!groups[i].name)
|
|
return -ENOMEM;
|
|
|
|
/* Add sysfs attributes of the Synapses */
|
|
err = counter_sysfs_synapses_add(counter, groups + i, count);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Create all attributes associated with Count */
|
|
err = counter_count_attrs_create(counter, groups + i, count);
|
|
if (err < 0)
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int counter_num_signals_read(struct counter_device *counter, u8 *val)
|
|
{
|
|
*val = counter->num_signals;
|
|
return 0;
|
|
}
|
|
|
|
static int counter_num_counts_read(struct counter_device *counter, u8 *val)
|
|
{
|
|
*val = counter->num_counts;
|
|
return 0;
|
|
}
|
|
|
|
static int counter_events_queue_size_read(struct counter_device *counter,
|
|
u64 *val)
|
|
{
|
|
*val = kfifo_size(&counter->events);
|
|
return 0;
|
|
}
|
|
|
|
static int counter_events_queue_size_write(struct counter_device *counter,
|
|
u64 val)
|
|
{
|
|
DECLARE_KFIFO_PTR(events, struct counter_event);
|
|
int err;
|
|
unsigned long flags;
|
|
|
|
/* Allocate new events queue */
|
|
err = kfifo_alloc(&events, val, GFP_KERNEL);
|
|
if (err)
|
|
return err;
|
|
|
|
/* Swap in new events queue */
|
|
mutex_lock(&counter->events_out_lock);
|
|
spin_lock_irqsave(&counter->events_in_lock, flags);
|
|
kfifo_free(&counter->events);
|
|
counter->events.kfifo = events.kfifo;
|
|
spin_unlock_irqrestore(&counter->events_in_lock, flags);
|
|
mutex_unlock(&counter->events_out_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct counter_comp counter_num_signals_comp =
|
|
COUNTER_COMP_DEVICE_U8("num_signals", counter_num_signals_read, NULL);
|
|
|
|
static struct counter_comp counter_num_counts_comp =
|
|
COUNTER_COMP_DEVICE_U8("num_counts", counter_num_counts_read, NULL);
|
|
|
|
static struct counter_comp counter_events_queue_size_comp =
|
|
COUNTER_COMP_DEVICE_U64("events_queue_size",
|
|
counter_events_queue_size_read,
|
|
counter_events_queue_size_write);
|
|
|
|
static int counter_sysfs_attr_add(struct counter_device *const counter,
|
|
struct counter_attribute_group *cattr_group)
|
|
{
|
|
const enum counter_scope scope = COUNTER_SCOPE_DEVICE;
|
|
struct device *const dev = &counter->dev;
|
|
int err;
|
|
|
|
/* Add Signals sysfs attributes */
|
|
err = counter_sysfs_signals_add(counter, cattr_group);
|
|
if (err < 0)
|
|
return err;
|
|
cattr_group += counter->num_signals;
|
|
|
|
/* Add Counts sysfs attributes */
|
|
err = counter_sysfs_counts_add(counter, cattr_group);
|
|
if (err < 0)
|
|
return err;
|
|
cattr_group += counter->num_counts;
|
|
|
|
/* Create name attribute */
|
|
err = counter_name_attr_create(dev, cattr_group, counter->name);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Create num_signals attribute */
|
|
err = counter_attr_create(dev, cattr_group, &counter_num_signals_comp,
|
|
scope, NULL);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Create num_counts attribute */
|
|
err = counter_attr_create(dev, cattr_group, &counter_num_counts_comp,
|
|
scope, NULL);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Create events_queue_size attribute */
|
|
err = counter_attr_create(dev, cattr_group,
|
|
&counter_events_queue_size_comp, scope, NULL);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Add device extensions */
|
|
return counter_sysfs_exts_add(dev, cattr_group, counter->ext,
|
|
counter->num_ext, scope, NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* counter_sysfs_add - Adds Counter sysfs attributes to the device structure
|
|
* @counter: Pointer to the Counter device structure
|
|
*
|
|
* Counter sysfs attributes are created and added to the respective device
|
|
* structure for later registration to the system. Resource-managed memory
|
|
* allocation is performed by this function, and this memory should be freed
|
|
* when no longer needed (automatically by a device_unregister call, or
|
|
* manually by a devres_release_all call).
|
|
*/
|
|
int counter_sysfs_add(struct counter_device *const counter)
|
|
{
|
|
struct device *const dev = &counter->dev;
|
|
const size_t num_groups = counter->num_signals + counter->num_counts + 1;
|
|
struct counter_attribute_group *cattr_groups;
|
|
size_t i, j;
|
|
int err;
|
|
struct attribute_group *groups;
|
|
struct counter_attribute *p;
|
|
|
|
/* Allocate space for attribute groups (signals, counts, and ext) */
|
|
cattr_groups = devm_kcalloc(dev, num_groups, sizeof(*cattr_groups),
|
|
GFP_KERNEL);
|
|
if (!cattr_groups)
|
|
return -ENOMEM;
|
|
|
|
/* Initialize attribute lists */
|
|
for (i = 0; i < num_groups; i++)
|
|
INIT_LIST_HEAD(&cattr_groups[i].attr_list);
|
|
|
|
/* Add Counter device sysfs attributes */
|
|
err = counter_sysfs_attr_add(counter, cattr_groups);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Allocate attribute group pointers for association with device */
|
|
dev->groups = devm_kcalloc(dev, num_groups + 1, sizeof(*dev->groups),
|
|
GFP_KERNEL);
|
|
if (!dev->groups)
|
|
return -ENOMEM;
|
|
|
|
/* Allocate space for attribute groups */
|
|
groups = devm_kcalloc(dev, num_groups, sizeof(*groups), GFP_KERNEL);
|
|
if (!groups)
|
|
return -ENOMEM;
|
|
|
|
/* Prepare each group of attributes for association */
|
|
for (i = 0; i < num_groups; i++) {
|
|
groups[i].name = cattr_groups[i].name;
|
|
|
|
/* Allocate space for attribute pointers */
|
|
groups[i].attrs = devm_kcalloc(dev,
|
|
cattr_groups[i].num_attr + 1,
|
|
sizeof(*groups[i].attrs),
|
|
GFP_KERNEL);
|
|
if (!groups[i].attrs)
|
|
return -ENOMEM;
|
|
|
|
/* Add attribute pointers to attribute group */
|
|
j = 0;
|
|
list_for_each_entry(p, &cattr_groups[i].attr_list, l)
|
|
groups[i].attrs[j++] = &p->dev_attr.attr;
|
|
|
|
/* Associate attribute group */
|
|
dev->groups[i] = &groups[i];
|
|
}
|
|
|
|
return 0;
|
|
}
|