// SPDX-License-Identifier: GPL-2.0 /* * Generic Counter interface * Copyright (C) 2018 William Breathitt Gray */ #include <linux/counter.h> #include <linux/device.h> #include <linux/err.h> #include <linux/export.h> #include <linux/fs.h> #include <linux/gfp.h> #include <linux/idr.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/list.h> #include <linux/module.h> #include <linux/printk.h> #include <linux/slab.h> #include <linux/string.h> #include <linux/sysfs.h> #include <linux/types.h> const char *const counter_count_direction_str[2] = { [COUNTER_COUNT_DIRECTION_FORWARD] = "forward", [COUNTER_COUNT_DIRECTION_BACKWARD] = "backward" }; EXPORT_SYMBOL_GPL(counter_count_direction_str); const char *const counter_count_mode_str[4] = { [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" }; EXPORT_SYMBOL_GPL(counter_count_mode_str); ssize_t counter_signal_enum_read(struct counter_device *counter, struct counter_signal *signal, void *priv, char *buf) { const struct counter_signal_enum_ext *const e = priv; int err; size_t index; if (!e->get) return -EINVAL; err = e->get(counter, signal, &index); if (err) return err; if (index >= e->num_items) return -EINVAL; return sprintf(buf, "%s\n", e->items[index]); } EXPORT_SYMBOL_GPL(counter_signal_enum_read); ssize_t counter_signal_enum_write(struct counter_device *counter, struct counter_signal *signal, void *priv, const char *buf, size_t len) { const struct counter_signal_enum_ext *const e = priv; ssize_t index; int err; if (!e->set) return -EINVAL; index = __sysfs_match_string(e->items, e->num_items, buf); if (index < 0) return index; err = e->set(counter, signal, index); if (err) return err; return len; } EXPORT_SYMBOL_GPL(counter_signal_enum_write); ssize_t counter_signal_enum_available_read(struct counter_device *counter, struct counter_signal *signal, void *priv, char *buf) { const struct counter_signal_enum_ext *const e = priv; size_t i; size_t len = 0; if (!e->num_items) return 0; for (i = 0; i < e->num_items; i++) len += sprintf(buf + len, "%s\n", e->items[i]); return len; } EXPORT_SYMBOL_GPL(counter_signal_enum_available_read); ssize_t counter_count_enum_read(struct counter_device *counter, struct counter_count *count, void *priv, char *buf) { const struct counter_count_enum_ext *const e = priv; int err; size_t index; if (!e->get) return -EINVAL; err = e->get(counter, count, &index); if (err) return err; if (index >= e->num_items) return -EINVAL; return sprintf(buf, "%s\n", e->items[index]); } EXPORT_SYMBOL_GPL(counter_count_enum_read); ssize_t counter_count_enum_write(struct counter_device *counter, struct counter_count *count, void *priv, const char *buf, size_t len) { const struct counter_count_enum_ext *const e = priv; ssize_t index; int err; if (!e->set) return -EINVAL; index = __sysfs_match_string(e->items, e->num_items, buf); if (index < 0) return index; err = e->set(counter, count, index); if (err) return err; return len; } EXPORT_SYMBOL_GPL(counter_count_enum_write); ssize_t counter_count_enum_available_read(struct counter_device *counter, struct counter_count *count, void *priv, char *buf) { const struct counter_count_enum_ext *const e = priv; size_t i; size_t len = 0; if (!e->num_items) return 0; for (i = 0; i < e->num_items; i++) len += sprintf(buf + len, "%s\n", e->items[i]); return len; } EXPORT_SYMBOL_GPL(counter_count_enum_available_read); ssize_t counter_device_enum_read(struct counter_device *counter, void *priv, char *buf) { const struct counter_device_enum_ext *const e = priv; int err; size_t index; if (!e->get) return -EINVAL; err = e->get(counter, &index); if (err) return err; if (index >= e->num_items) return -EINVAL; return sprintf(buf, "%s\n", e->items[index]); } EXPORT_SYMBOL_GPL(counter_device_enum_read); ssize_t counter_device_enum_write(struct counter_device *counter, void *priv, const char *buf, size_t len) { const struct counter_device_enum_ext *const e = priv; ssize_t index; int err; if (!e->set) return -EINVAL; index = __sysfs_match_string(e->items, e->num_items, buf); if (index < 0) return index; err = e->set(counter, index); if (err) return err; return len; } EXPORT_SYMBOL_GPL(counter_device_enum_write); ssize_t counter_device_enum_available_read(struct counter_device *counter, void *priv, char *buf) { const struct counter_device_enum_ext *const e = priv; size_t i; size_t len = 0; if (!e->num_items) return 0; for (i = 0; i < e->num_items; i++) len += sprintf(buf + len, "%s\n", e->items[i]); return len; } EXPORT_SYMBOL_GPL(counter_device_enum_available_read); struct counter_attr_parm { struct counter_device_attr_group *group; const char *prefix; const char *name; ssize_t (*show)(struct device *dev, struct device_attribute *attr, char *buf); ssize_t (*store)(struct device *dev, struct device_attribute *attr, const char *buf, size_t len); void *component; }; struct counter_device_attr { struct device_attribute dev_attr; struct list_head l; void *component; }; static int counter_attribute_create(const struct counter_attr_parm *const parm) { struct counter_device_attr *counter_attr; struct device_attribute *dev_attr; int err; struct list_head *const attr_list = &parm->group->attr_list; /* Allocate a Counter device attribute */ counter_attr = kzalloc(sizeof(*counter_attr), GFP_KERNEL); if (!counter_attr) return -ENOMEM; dev_attr = &counter_attr->dev_attr; sysfs_attr_init(&dev_attr->attr); /* Configure device attribute */ dev_attr->attr.name = kasprintf(GFP_KERNEL, "%s%s", parm->prefix, parm->name); if (!dev_attr->attr.name) { err = -ENOMEM; goto err_free_counter_attr; } if (parm->show) { dev_attr->attr.mode |= 0444; dev_attr->show = parm->show; } if (parm->store) { dev_attr->attr.mode |= 0200; dev_attr->store = parm->store; } /* Store associated Counter component with attribute */ counter_attr->component = parm->component; /* Keep track of the attribute for later cleanup */ list_add(&counter_attr->l, attr_list); parm->group->num_attr++; return 0; err_free_counter_attr: kfree(counter_attr); return err; } #define to_counter_attr(_dev_attr) \ container_of(_dev_attr, struct counter_device_attr, dev_attr) struct counter_signal_unit { struct counter_signal *signal; }; static const char *const counter_signal_value_str[] = { [COUNTER_SIGNAL_LOW] = "low", [COUNTER_SIGNAL_HIGH] = "high" }; static ssize_t counter_signal_show(struct device *dev, struct device_attribute *attr, char *buf) { struct counter_device *const counter = dev_get_drvdata(dev); const struct counter_device_attr *const devattr = to_counter_attr(attr); const struct counter_signal_unit *const component = devattr->component; struct counter_signal *const signal = component->signal; int err; enum counter_signal_value val; err = counter->ops->signal_read(counter, signal, &val); if (err) return err; return sprintf(buf, "%s\n", counter_signal_value_str[val]); } struct counter_name_unit { const char *name; }; static ssize_t counter_device_attr_name_show(struct device *dev, struct device_attribute *attr, char *buf) { const struct counter_name_unit *const comp = to_counter_attr(attr)->component; return sprintf(buf, "%s\n", comp->name); } static int counter_name_attribute_create( struct counter_device_attr_group *const group, const char *const name) { struct counter_name_unit *name_comp; struct counter_attr_parm parm; int err; /* Skip if no name */ if (!name) return 0; /* Allocate name attribute component */ name_comp = kmalloc(sizeof(*name_comp), GFP_KERNEL); if (!name_comp) return -ENOMEM; name_comp->name = name; /* Allocate Signal name attribute */ parm.group = group; parm.prefix = ""; parm.name = "name"; parm.show = counter_device_attr_name_show; parm.store = NULL; parm.component = name_comp; err = counter_attribute_create(&parm); if (err) goto err_free_name_comp; return 0; err_free_name_comp: kfree(name_comp); return err; } struct counter_signal_ext_unit { struct counter_signal *signal; const struct counter_signal_ext *ext; }; static ssize_t counter_signal_ext_show(struct device *dev, struct device_attribute *attr, char *buf) { const struct counter_device_attr *const devattr = to_counter_attr(attr); const struct counter_signal_ext_unit *const comp = devattr->component; const struct counter_signal_ext *const ext = comp->ext; return ext->read(dev_get_drvdata(dev), comp->signal, ext->priv, buf); } static ssize_t counter_signal_ext_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { const struct counter_device_attr *const devattr = to_counter_attr(attr); const struct counter_signal_ext_unit *const comp = devattr->component; const struct counter_signal_ext *const ext = comp->ext; return ext->write(dev_get_drvdata(dev), comp->signal, ext->priv, buf, len); } static void counter_device_attr_list_free(struct list_head *attr_list) { struct counter_device_attr *p, *n; list_for_each_entry_safe(p, n, attr_list, l) { /* free attribute name and associated component memory */ kfree(p->dev_attr.attr.name); kfree(p->component); list_del(&p->l); kfree(p); } } static int counter_signal_ext_register( struct counter_device_attr_group *const group, struct counter_signal *const signal) { const size_t num_ext = signal->num_ext; size_t i; const struct counter_signal_ext *ext; struct counter_signal_ext_unit *signal_ext_comp; struct counter_attr_parm parm; int err; /* Create an attribute for each extension */ for (i = 0 ; i < num_ext; i++) { ext = signal->ext + i; /* Allocate signal_ext attribute component */ signal_ext_comp = kmalloc(sizeof(*signal_ext_comp), GFP_KERNEL); if (!signal_ext_comp) { err = -ENOMEM; goto err_free_attr_list; } signal_ext_comp->signal = signal; signal_ext_comp->ext = ext; /* Allocate a Counter device attribute */ parm.group = group; parm.prefix = ""; parm.name = ext->name; parm.show = (ext->read) ? counter_signal_ext_show : NULL; parm.store = (ext->write) ? counter_signal_ext_store : NULL; parm.component = signal_ext_comp; err = counter_attribute_create(&parm); if (err) { kfree(signal_ext_comp); goto err_free_attr_list; } } return 0; err_free_attr_list: counter_device_attr_list_free(&group->attr_list); return err; } static int counter_signal_attributes_create( struct counter_device_attr_group *const group, const struct counter_device *const counter, struct counter_signal *const signal) { struct counter_signal_unit *signal_comp; struct counter_attr_parm parm; int err; /* Allocate Signal attribute component */ signal_comp = kmalloc(sizeof(*signal_comp), GFP_KERNEL); if (!signal_comp) return -ENOMEM; signal_comp->signal = signal; /* Create main Signal attribute */ parm.group = group; parm.prefix = ""; parm.name = "signal"; parm.show = (counter->ops->signal_read) ? counter_signal_show : NULL; parm.store = NULL; parm.component = signal_comp; err = counter_attribute_create(&parm); if (err) { kfree(signal_comp); return err; } /* Create Signal name attribute */ err = counter_name_attribute_create(group, signal->name); if (err) goto err_free_attr_list; /* Register Signal extension attributes */ err = counter_signal_ext_register(group, signal); if (err) goto err_free_attr_list; return 0; err_free_attr_list: counter_device_attr_list_free(&group->attr_list); return err; } static int counter_signals_register( struct counter_device_attr_group *const groups_list, const struct counter_device *const counter) { const size_t num_signals = counter->num_signals; size_t i; struct counter_signal *signal; const char *name; int err; /* Register each Signal */ for (i = 0; i < num_signals; i++) { signal = counter->signals + i; /* Generate Signal attribute directory name */ name = kasprintf(GFP_KERNEL, "signal%d", signal->id); if (!name) { err = -ENOMEM; goto err_free_attr_groups; } groups_list[i].attr_group.name = name; /* Create all attributes associated with Signal */ err = counter_signal_attributes_create(groups_list + i, counter, signal); if (err) goto err_free_attr_groups; } return 0; err_free_attr_groups: do { kfree(groups_list[i].attr_group.name); counter_device_attr_list_free(&groups_list[i].attr_list); } while (i--); return err; } 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" }; struct counter_action_unit { struct counter_synapse *synapse; struct counter_count *count; }; static ssize_t counter_action_show(struct device *dev, struct device_attribute *attr, char *buf) { const struct counter_device_attr *const devattr = to_counter_attr(attr); int err; struct counter_device *const counter = dev_get_drvdata(dev); const struct counter_action_unit *const component = devattr->component; struct counter_count *const count = component->count; struct counter_synapse *const synapse = component->synapse; size_t action_index; enum counter_synapse_action action; err = counter->ops->action_get(counter, count, synapse, &action_index); if (err) return err; synapse->action = action_index; action = synapse->actions_list[action_index]; return sprintf(buf, "%s\n", counter_synapse_action_str[action]); } static ssize_t counter_action_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { const struct counter_device_attr *const devattr = to_counter_attr(attr); const struct counter_action_unit *const component = devattr->component; struct counter_synapse *const synapse = component->synapse; size_t action_index; const size_t num_actions = synapse->num_actions; enum counter_synapse_action action; int err; struct counter_device *const counter = dev_get_drvdata(dev); struct counter_count *const count = component->count; /* Find requested action mode */ for (action_index = 0; action_index < num_actions; action_index++) { action = synapse->actions_list[action_index]; if (sysfs_streq(buf, counter_synapse_action_str[action])) break; } /* If requested action mode not found */ if (action_index >= num_actions) return -EINVAL; err = counter->ops->action_set(counter, count, synapse, action_index); if (err) return err; synapse->action = action_index; return len; } struct counter_action_avail_unit { const enum counter_synapse_action *actions_list; size_t num_actions; }; static ssize_t counter_synapse_action_available_show(struct device *dev, struct device_attribute *attr, char *buf) { const struct counter_device_attr *const devattr = to_counter_attr(attr); const struct counter_action_avail_unit *const component = devattr->component; size_t i; enum counter_synapse_action action; ssize_t len = 0; for (i = 0; i < component->num_actions; i++) { action = component->actions_list[i]; len += sprintf(buf + len, "%s\n", counter_synapse_action_str[action]); } return len; } static int counter_synapses_register( struct counter_device_attr_group *const group, const struct counter_device *const counter, struct counter_count *const count, const char *const count_attr_name) { size_t i; struct counter_synapse *synapse; const char *prefix; struct counter_action_unit *action_comp; struct counter_attr_parm parm; int err; struct counter_action_avail_unit *avail_comp; /* Register each Synapse */ for (i = 0; i < count->num_synapses; i++) { synapse = count->synapses + i; /* Generate attribute prefix */ prefix = kasprintf(GFP_KERNEL, "signal%d_", synapse->signal->id); if (!prefix) { err = -ENOMEM; goto err_free_attr_list; } /* Allocate action attribute component */ action_comp = kmalloc(sizeof(*action_comp), GFP_KERNEL); if (!action_comp) { err = -ENOMEM; goto err_free_prefix; } action_comp->synapse = synapse; action_comp->count = count; /* Create action attribute */ parm.group = group; parm.prefix = prefix; parm.name = "action"; parm.show = (counter->ops->action_get) ? counter_action_show : NULL; parm.store = (counter->ops->action_set) ? counter_action_store : NULL; parm.component = action_comp; err = counter_attribute_create(&parm); if (err) { kfree(action_comp); goto err_free_prefix; } /* Allocate action available attribute component */ avail_comp = kmalloc(sizeof(*avail_comp), GFP_KERNEL); if (!avail_comp) { err = -ENOMEM; goto err_free_prefix; } avail_comp->actions_list = synapse->actions_list; avail_comp->num_actions = synapse->num_actions; /* Create action_available attribute */ parm.group = group; parm.prefix = prefix; parm.name = "action_available"; parm.show = counter_synapse_action_available_show; parm.store = NULL; parm.component = avail_comp; err = counter_attribute_create(&parm); if (err) { kfree(avail_comp); goto err_free_prefix; } kfree(prefix); } return 0; err_free_prefix: kfree(prefix); err_free_attr_list: counter_device_attr_list_free(&group->attr_list); return err; } struct counter_count_unit { struct counter_count *count; }; static ssize_t counter_count_show(struct device *dev, struct device_attribute *attr, char *buf) { struct counter_device *const counter = dev_get_drvdata(dev); const struct counter_device_attr *const devattr = to_counter_attr(attr); const struct counter_count_unit *const component = devattr->component; struct counter_count *const count = component->count; int err; unsigned long val; err = counter->ops->count_read(counter, count, &val); if (err) return err; return sprintf(buf, "%lu\n", val); } static ssize_t counter_count_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct counter_device *const counter = dev_get_drvdata(dev); const struct counter_device_attr *const devattr = to_counter_attr(attr); const struct counter_count_unit *const component = devattr->component; struct counter_count *const count = component->count; int err; unsigned long val; err = kstrtoul(buf, 0, &val); if (err) return err; err = counter->ops->count_write(counter, count, val); if (err) return err; return len; } static const char *const counter_count_function_str[] = { [COUNTER_COUNT_FUNCTION_INCREASE] = "increase", [COUNTER_COUNT_FUNCTION_DECREASE] = "decrease", [COUNTER_COUNT_FUNCTION_PULSE_DIRECTION] = "pulse-direction", [COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A] = "quadrature x1 a", [COUNTER_COUNT_FUNCTION_QUADRATURE_X1_B] = "quadrature x1 b", [COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A] = "quadrature x2 a", [COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B] = "quadrature x2 b", [COUNTER_COUNT_FUNCTION_QUADRATURE_X4] = "quadrature x4" }; static ssize_t counter_function_show(struct device *dev, struct device_attribute *attr, char *buf) { int err; struct counter_device *const counter = dev_get_drvdata(dev); const struct counter_device_attr *const devattr = to_counter_attr(attr); const struct counter_count_unit *const component = devattr->component; struct counter_count *const count = component->count; size_t func_index; enum counter_count_function function; err = counter->ops->function_get(counter, count, &func_index); if (err) return err; count->function = func_index; function = count->functions_list[func_index]; return sprintf(buf, "%s\n", counter_count_function_str[function]); } static ssize_t counter_function_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { const struct counter_device_attr *const devattr = to_counter_attr(attr); const struct counter_count_unit *const component = devattr->component; struct counter_count *const count = component->count; const size_t num_functions = count->num_functions; size_t func_index; enum counter_count_function function; int err; struct counter_device *const counter = dev_get_drvdata(dev); /* Find requested Count function mode */ for (func_index = 0; func_index < num_functions; func_index++) { function = count->functions_list[func_index]; if (sysfs_streq(buf, counter_count_function_str[function])) break; } /* Return error if requested Count function mode not found */ if (func_index >= num_functions) return -EINVAL; err = counter->ops->function_set(counter, count, func_index); if (err) return err; count->function = func_index; return len; } struct counter_count_ext_unit { struct counter_count *count; const struct counter_count_ext *ext; }; static ssize_t counter_count_ext_show(struct device *dev, struct device_attribute *attr, char *buf) { const struct counter_device_attr *const devattr = to_counter_attr(attr); const struct counter_count_ext_unit *const comp = devattr->component; const struct counter_count_ext *const ext = comp->ext; return ext->read(dev_get_drvdata(dev), comp->count, ext->priv, buf); } static ssize_t counter_count_ext_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { const struct counter_device_attr *const devattr = to_counter_attr(attr); const struct counter_count_ext_unit *const comp = devattr->component; const struct counter_count_ext *const ext = comp->ext; return ext->write(dev_get_drvdata(dev), comp->count, ext->priv, buf, len); } static int counter_count_ext_register( struct counter_device_attr_group *const group, struct counter_count *const count) { size_t i; const struct counter_count_ext *ext; struct counter_count_ext_unit *count_ext_comp; struct counter_attr_parm parm; int err; /* Create an attribute for each extension */ for (i = 0 ; i < count->num_ext; i++) { ext = count->ext + i; /* Allocate count_ext attribute component */ count_ext_comp = kmalloc(sizeof(*count_ext_comp), GFP_KERNEL); if (!count_ext_comp) { err = -ENOMEM; goto err_free_attr_list; } count_ext_comp->count = count; count_ext_comp->ext = ext; /* Allocate count_ext attribute */ parm.group = group; parm.prefix = ""; parm.name = ext->name; parm.show = (ext->read) ? counter_count_ext_show : NULL; parm.store = (ext->write) ? counter_count_ext_store : NULL; parm.component = count_ext_comp; err = counter_attribute_create(&parm); if (err) { kfree(count_ext_comp); goto err_free_attr_list; } } return 0; err_free_attr_list: counter_device_attr_list_free(&group->attr_list); return err; } struct counter_func_avail_unit { const enum counter_count_function *functions_list; size_t num_functions; }; static ssize_t counter_count_function_available_show(struct device *dev, struct device_attribute *attr, char *buf) { const struct counter_device_attr *const devattr = to_counter_attr(attr); const struct counter_func_avail_unit *const component = devattr->component; const enum counter_count_function *const func_list = component->functions_list; const size_t num_functions = component->num_functions; size_t i; enum counter_count_function function; ssize_t len = 0; for (i = 0; i < num_functions; i++) { function = func_list[i]; len += sprintf(buf + len, "%s\n", counter_count_function_str[function]); } return len; } static int counter_count_attributes_create( struct counter_device_attr_group *const group, const struct counter_device *const counter, struct counter_count *const count) { struct counter_count_unit *count_comp; struct counter_attr_parm parm; int err; struct counter_count_unit *func_comp; struct counter_func_avail_unit *avail_comp; /* Allocate count attribute component */ count_comp = kmalloc(sizeof(*count_comp), GFP_KERNEL); if (!count_comp) return -ENOMEM; count_comp->count = count; /* Create main Count attribute */ parm.group = group; parm.prefix = ""; parm.name = "count"; parm.show = (counter->ops->count_read) ? counter_count_show : NULL; parm.store = (counter->ops->count_write) ? counter_count_store : NULL; parm.component = count_comp; err = counter_attribute_create(&parm); if (err) { kfree(count_comp); return err; } /* Allocate function attribute component */ func_comp = kmalloc(sizeof(*func_comp), GFP_KERNEL); if (!func_comp) { err = -ENOMEM; goto err_free_attr_list; } func_comp->count = count; /* Create Count function attribute */ parm.group = group; parm.prefix = ""; parm.name = "function"; parm.show = (counter->ops->function_get) ? counter_function_show : NULL; parm.store = (counter->ops->function_set) ? counter_function_store : NULL; parm.component = func_comp; err = counter_attribute_create(&parm); if (err) { kfree(func_comp); goto err_free_attr_list; } /* Allocate function available attribute component */ avail_comp = kmalloc(sizeof(*avail_comp), GFP_KERNEL); if (!avail_comp) { err = -ENOMEM; goto err_free_attr_list; } avail_comp->functions_list = count->functions_list; avail_comp->num_functions = count->num_functions; /* Create Count function_available attribute */ parm.group = group; parm.prefix = ""; parm.name = "function_available"; parm.show = counter_count_function_available_show; parm.store = NULL; parm.component = avail_comp; err = counter_attribute_create(&parm); if (err) { kfree(avail_comp); goto err_free_attr_list; } /* Create Count name attribute */ err = counter_name_attribute_create(group, count->name); if (err) goto err_free_attr_list; /* Register Count extension attributes */ err = counter_count_ext_register(group, count); if (err) goto err_free_attr_list; return 0; err_free_attr_list: counter_device_attr_list_free(&group->attr_list); return err; } static int counter_counts_register( struct counter_device_attr_group *const groups_list, const struct counter_device *const counter) { size_t i; struct counter_count *count; const char *name; int err; /* Register each Count */ for (i = 0; i < counter->num_counts; i++) { count = counter->counts + i; /* Generate Count attribute directory name */ name = kasprintf(GFP_KERNEL, "count%d", count->id); if (!name) { err = -ENOMEM; goto err_free_attr_groups; } groups_list[i].attr_group.name = name; /* Register the Synapses associated with each Count */ err = counter_synapses_register(groups_list + i, counter, count, name); if (err) goto err_free_attr_groups; /* Create all attributes associated with Count */ err = counter_count_attributes_create(groups_list + i, counter, count); if (err) goto err_free_attr_groups; } return 0; err_free_attr_groups: do { kfree(groups_list[i].attr_group.name); counter_device_attr_list_free(&groups_list[i].attr_list); } while (i--); return err; } struct counter_size_unit { size_t size; }; static ssize_t counter_device_attr_size_show(struct device *dev, struct device_attribute *attr, char *buf) { const struct counter_size_unit *const comp = to_counter_attr(attr)->component; return sprintf(buf, "%zu\n", comp->size); } static int counter_size_attribute_create( struct counter_device_attr_group *const group, const size_t size, const char *const name) { struct counter_size_unit *size_comp; struct counter_attr_parm parm; int err; /* Allocate size attribute component */ size_comp = kmalloc(sizeof(*size_comp), GFP_KERNEL); if (!size_comp) return -ENOMEM; size_comp->size = size; parm.group = group; parm.prefix = ""; parm.name = name; parm.show = counter_device_attr_size_show; parm.store = NULL; parm.component = size_comp; err = counter_attribute_create(&parm); if (err) goto err_free_size_comp; return 0; err_free_size_comp: kfree(size_comp); return err; } struct counter_ext_unit { const struct counter_device_ext *ext; }; static ssize_t counter_device_ext_show(struct device *dev, struct device_attribute *attr, char *buf) { const struct counter_device_attr *const devattr = to_counter_attr(attr); const struct counter_ext_unit *const component = devattr->component; const struct counter_device_ext *const ext = component->ext; return ext->read(dev_get_drvdata(dev), ext->priv, buf); } static ssize_t counter_device_ext_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { const struct counter_device_attr *const devattr = to_counter_attr(attr); const struct counter_ext_unit *const component = devattr->component; const struct counter_device_ext *const ext = component->ext; return ext->write(dev_get_drvdata(dev), ext->priv, buf, len); } static int counter_device_ext_register( struct counter_device_attr_group *const group, struct counter_device *const counter) { size_t i; struct counter_ext_unit *ext_comp; struct counter_attr_parm parm; int err; /* Create an attribute for each extension */ for (i = 0 ; i < counter->num_ext; i++) { /* Allocate extension attribute component */ ext_comp = kmalloc(sizeof(*ext_comp), GFP_KERNEL); if (!ext_comp) { err = -ENOMEM; goto err_free_attr_list; } ext_comp->ext = counter->ext + i; /* Allocate extension attribute */ parm.group = group; parm.prefix = ""; parm.name = counter->ext[i].name; parm.show = (counter->ext[i].read) ? counter_device_ext_show : NULL; parm.store = (counter->ext[i].write) ? counter_device_ext_store : NULL; parm.component = ext_comp; err = counter_attribute_create(&parm); if (err) { kfree(ext_comp); goto err_free_attr_list; } } return 0; err_free_attr_list: counter_device_attr_list_free(&group->attr_list); return err; } static int counter_global_attr_register( struct counter_device_attr_group *const group, struct counter_device *const counter) { int err; /* Create name attribute */ err = counter_name_attribute_create(group, counter->name); if (err) return err; /* Create num_counts attribute */ err = counter_size_attribute_create(group, counter->num_counts, "num_counts"); if (err) goto err_free_attr_list; /* Create num_signals attribute */ err = counter_size_attribute_create(group, counter->num_signals, "num_signals"); if (err) goto err_free_attr_list; /* Register Counter device extension attributes */ err = counter_device_ext_register(group, counter); if (err) goto err_free_attr_list; return 0; err_free_attr_list: counter_device_attr_list_free(&group->attr_list); return err; } static void counter_device_groups_list_free( struct counter_device_attr_group *const groups_list, const size_t num_groups) { struct counter_device_attr_group *group; size_t i; /* loop through all attribute groups (signals, counts, global, etc.) */ for (i = 0; i < num_groups; i++) { group = groups_list + i; /* free all attribute group and associated attributes memory */ kfree(group->attr_group.name); kfree(group->attr_group.attrs); counter_device_attr_list_free(&group->attr_list); } kfree(groups_list); } static int counter_device_groups_list_prepare( struct counter_device *const counter) { const size_t total_num_groups = counter->num_signals + counter->num_counts + 1; struct counter_device_attr_group *groups_list; size_t i; int err; size_t num_groups = 0; /* Allocate space for attribute groups (signals, counts, and ext) */ groups_list = kcalloc(total_num_groups, sizeof(*groups_list), GFP_KERNEL); if (!groups_list) return -ENOMEM; /* Initialize attribute lists */ for (i = 0; i < total_num_groups; i++) INIT_LIST_HEAD(&groups_list[i].attr_list); /* Register Signals */ err = counter_signals_register(groups_list, counter); if (err) goto err_free_groups_list; num_groups += counter->num_signals; /* Register Counts and respective Synapses */ err = counter_counts_register(groups_list + num_groups, counter); if (err) goto err_free_groups_list; num_groups += counter->num_counts; /* Register Counter global attributes */ err = counter_global_attr_register(groups_list + num_groups, counter); if (err) goto err_free_groups_list; num_groups++; /* Store groups_list in device_state */ counter->device_state->groups_list = groups_list; counter->device_state->num_groups = num_groups; return 0; err_free_groups_list: counter_device_groups_list_free(groups_list, num_groups); return err; } static int counter_device_groups_prepare( struct counter_device_state *const device_state) { size_t i, j; struct counter_device_attr_group *group; int err; struct counter_device_attr *p; /* Allocate attribute groups for association with device */ device_state->groups = kcalloc(device_state->num_groups + 1, sizeof(*device_state->groups), GFP_KERNEL); if (!device_state->groups) return -ENOMEM; /* Prepare each group of attributes for association */ for (i = 0; i < device_state->num_groups; i++) { group = device_state->groups_list + i; /* Allocate space for attribute pointers in attribute group */ group->attr_group.attrs = kcalloc(group->num_attr + 1, sizeof(*group->attr_group.attrs), GFP_KERNEL); if (!group->attr_group.attrs) { err = -ENOMEM; goto err_free_groups; } /* Add attribute pointers to attribute group */ j = 0; list_for_each_entry(p, &group->attr_list, l) group->attr_group.attrs[j++] = &p->dev_attr.attr; /* Group attributes in attribute group */ device_state->groups[i] = &group->attr_group; } /* Associate attributes with device */ device_state->dev.groups = device_state->groups; return 0; err_free_groups: do { group = device_state->groups_list + i; kfree(group->attr_group.attrs); group->attr_group.attrs = NULL; } while (i--); kfree(device_state->groups); return err; } /* Provides a unique ID for each counter device */ static DEFINE_IDA(counter_ida); static void counter_device_release(struct device *dev) { struct counter_device *const counter = dev_get_drvdata(dev); struct counter_device_state *const device_state = counter->device_state; kfree(device_state->groups); counter_device_groups_list_free(device_state->groups_list, device_state->num_groups); ida_simple_remove(&counter_ida, device_state->id); kfree(device_state); } static struct device_type counter_device_type = { .name = "counter_device", .release = counter_device_release }; static struct bus_type counter_bus_type = { .name = "counter" }; /** * counter_register - register Counter to the system * @counter: pointer to Counter to register * * This function registers a Counter to the system. A sysfs "counter" directory * will be created and populated with sysfs attributes correlating with the * Counter Signals, Synapses, and Counts respectively. */ int counter_register(struct counter_device *const counter) { struct counter_device_state *device_state; int err; /* Allocate internal state container for Counter device */ device_state = kzalloc(sizeof(*device_state), GFP_KERNEL); if (!device_state) return -ENOMEM; counter->device_state = device_state; /* Acquire unique ID */ device_state->id = ida_simple_get(&counter_ida, 0, 0, GFP_KERNEL); if (device_state->id < 0) { err = device_state->id; goto err_free_device_state; } /* Configure device structure for Counter */ device_state->dev.type = &counter_device_type; device_state->dev.bus = &counter_bus_type; if (counter->parent) { device_state->dev.parent = counter->parent; device_state->dev.of_node = counter->parent->of_node; } dev_set_name(&device_state->dev, "counter%d", device_state->id); device_initialize(&device_state->dev); dev_set_drvdata(&device_state->dev, counter); /* Prepare device attributes */ err = counter_device_groups_list_prepare(counter); if (err) goto err_free_id; /* Organize device attributes to groups and match to device */ err = counter_device_groups_prepare(device_state); if (err) goto err_free_groups_list; /* Add device to system */ err = device_add(&device_state->dev); if (err) goto err_free_groups; return 0; err_free_groups: kfree(device_state->groups); err_free_groups_list: counter_device_groups_list_free(device_state->groups_list, device_state->num_groups); err_free_id: ida_simple_remove(&counter_ida, device_state->id); err_free_device_state: kfree(device_state); return err; } EXPORT_SYMBOL_GPL(counter_register); /** * counter_unregister - unregister Counter from the system * @counter: pointer to Counter to unregister * * The Counter is unregistered from the system; all allocated memory is freed. */ void counter_unregister(struct counter_device *const counter) { if (counter) device_del(&counter->device_state->dev); } EXPORT_SYMBOL_GPL(counter_unregister); static void devm_counter_unreg(struct device *dev, void *res) { counter_unregister(*(struct counter_device **)res); } /** * devm_counter_register - Resource-managed counter_register * @dev: device to allocate counter_device for * @counter: pointer to Counter to register * * Managed counter_register. The Counter registered with this function is * automatically unregistered on driver detach. This function calls * counter_register internally. Refer to that function for more information. * * If an Counter registered with this function needs to be unregistered * separately, devm_counter_unregister must be used. * * RETURNS: * 0 on success, negative error number on failure. */ int devm_counter_register(struct device *dev, struct counter_device *const counter) { struct counter_device **ptr; int ret; ptr = devres_alloc(devm_counter_unreg, sizeof(*ptr), GFP_KERNEL); if (!ptr) return -ENOMEM; ret = counter_register(counter); if (!ret) { *ptr = counter; devres_add(dev, ptr); } else { devres_free(ptr); } return ret; } EXPORT_SYMBOL_GPL(devm_counter_register); static int devm_counter_match(struct device *dev, void *res, void *data) { struct counter_device **r = res; if (!r || !*r) { WARN_ON(!r || !*r); return 0; } return *r == data; } /** * devm_counter_unregister - Resource-managed counter_unregister * @dev: device this counter_device belongs to * @counter: pointer to Counter associated with the device * * Unregister Counter registered with devm_counter_register. */ void devm_counter_unregister(struct device *dev, struct counter_device *const counter) { int rc; rc = devres_release(dev, devm_counter_unreg, devm_counter_match, counter); WARN_ON(rc); } EXPORT_SYMBOL_GPL(devm_counter_unregister); static int __init counter_init(void) { return bus_register(&counter_bus_type); } static void __exit counter_exit(void) { bus_unregister(&counter_bus_type); } subsys_initcall(counter_init); module_exit(counter_exit); MODULE_AUTHOR("William Breathitt Gray <vilhelm.gray@gmail.com>"); MODULE_DESCRIPTION("Generic Counter interface"); MODULE_LICENSE("GPL v2");