// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2020 Linaro Limited, All rights reserved.
 * Author: Mike Leach <mike.leach@linaro.org>
 */

#include <linux/configfs.h>

#include "coresight-config.h"
#include "coresight-syscfg-configfs.h"

/* create a default ci_type. */
static struct config_item_type *cscfg_create_ci_type(void)
{
        struct config_item_type *ci_type;

        ci_type = devm_kzalloc(cscfg_device(), sizeof(*ci_type), GFP_KERNEL);
        if (ci_type)
                ci_type->ct_owner = THIS_MODULE;

        return ci_type;
}

/* configurations sub-group */

/* attributes for the config view group */
static ssize_t cscfg_cfg_description_show(struct config_item *item, char *page)
{
        struct cscfg_fs_config *fs_config = container_of(to_config_group(item),
                                                         struct cscfg_fs_config, group);

        return scnprintf(page, PAGE_SIZE, "%s", fs_config->config_desc->description);
}
CONFIGFS_ATTR_RO(cscfg_cfg_, description);

static ssize_t cscfg_cfg_feature_refs_show(struct config_item *item, char *page)
{
        struct cscfg_fs_config *fs_config = container_of(to_config_group(item),
                                                         struct cscfg_fs_config, group);
        const struct cscfg_config_desc *config_desc = fs_config->config_desc;
        ssize_t ch_used = 0;
        int i;

        for (i = 0; i < config_desc->nr_feat_refs; i++)
                ch_used += scnprintf(page + ch_used, PAGE_SIZE - ch_used,
                                     "%s\n", config_desc->feat_ref_names[i]);
        return ch_used;
}
CONFIGFS_ATTR_RO(cscfg_cfg_, feature_refs);

/* list preset values in order of features and params */
static ssize_t cscfg_cfg_values_show(struct config_item *item, char *page)
{
        const struct cscfg_feature_desc *feat_desc;
        const struct cscfg_config_desc *config_desc;
        struct cscfg_fs_preset *fs_preset;
        int i, j, val_idx, preset_idx;
        ssize_t used = 0;

        fs_preset = container_of(to_config_group(item), struct cscfg_fs_preset, group);
        config_desc = fs_preset->config_desc;

        if (!config_desc->nr_presets)
                return 0;

        preset_idx = fs_preset->preset_num - 1;

        /* start index on the correct array line */
        val_idx = config_desc->nr_total_params * preset_idx;

        /*
         * A set of presets is the sum of all params in used features,
         * in order of declaration of features and params in the features
         */
        for (i = 0; i < config_desc->nr_feat_refs; i++) {
                feat_desc = cscfg_get_named_feat_desc(config_desc->feat_ref_names[i]);
                for (j = 0; j < feat_desc->nr_params; j++) {
                        used += scnprintf(page + used, PAGE_SIZE - used,
                                          "%s.%s = 0x%llx ",
                                          feat_desc->name,
                                          feat_desc->params_desc[j].name,
                                          config_desc->presets[val_idx++]);
                }
        }
        used += scnprintf(page + used, PAGE_SIZE - used, "\n");

        return used;
}
CONFIGFS_ATTR_RO(cscfg_cfg_, values);

static ssize_t cscfg_cfg_enable_show(struct config_item *item, char *page)
{
        struct cscfg_fs_config *fs_config = container_of(to_config_group(item),
                                                         struct cscfg_fs_config, group);

        return scnprintf(page, PAGE_SIZE, "%d\n", fs_config->active);
}

static ssize_t cscfg_cfg_enable_store(struct config_item *item,
                                        const char *page, size_t count)
{
        struct cscfg_fs_config *fs_config = container_of(to_config_group(item),
                                                         struct cscfg_fs_config, group);
        int err;
        bool val;

        err = kstrtobool(page, &val);
        if (!err)
                err = cscfg_config_sysfs_activate(fs_config->config_desc, val);
        if (!err) {
                fs_config->active = val;
                if (val)
                        cscfg_config_sysfs_set_preset(fs_config->preset);
        }
        return err ? err : count;
}
CONFIGFS_ATTR(cscfg_cfg_, enable);

static ssize_t cscfg_cfg_preset_show(struct config_item *item, char *page)
{
        struct cscfg_fs_config *fs_config = container_of(to_config_group(item),
                                                         struct cscfg_fs_config, group);

        return scnprintf(page, PAGE_SIZE, "%d\n", fs_config->preset);
}

static ssize_t cscfg_cfg_preset_store(struct config_item *item,
                                             const char *page, size_t count)
{
        struct cscfg_fs_config *fs_config = container_of(to_config_group(item),
                                                         struct cscfg_fs_config, group);
        int preset, err;

        err = kstrtoint(page, 0, &preset);
        if (!err) {
                /*
                 * presets start at 1, and go up to max (15),
                 * but the config may provide fewer.
                 */
                if ((preset < 1) || (preset > fs_config->config_desc->nr_presets))
                        err = -EINVAL;
        }

        if (!err) {
                /* set new value */
                fs_config->preset = preset;
                /* set on system if active */
                if (fs_config->active)
                        cscfg_config_sysfs_set_preset(fs_config->preset);
        }
        return err ? err : count;
}
CONFIGFS_ATTR(cscfg_cfg_, preset);

static struct configfs_attribute *cscfg_config_view_attrs[] = {
        &cscfg_cfg_attr_description,
        &cscfg_cfg_attr_feature_refs,
        &cscfg_cfg_attr_enable,
        &cscfg_cfg_attr_preset,
        NULL,
};

static const struct config_item_type cscfg_config_view_type = {
        .ct_owner = THIS_MODULE,
        .ct_attrs = cscfg_config_view_attrs,
};

static struct configfs_attribute *cscfg_config_preset_attrs[] = {
        &cscfg_cfg_attr_values,
        NULL,
};

static const struct config_item_type cscfg_config_preset_type = {
        .ct_owner = THIS_MODULE,
        .ct_attrs = cscfg_config_preset_attrs,
};

static int cscfg_add_preset_groups(struct cscfg_fs_config *cfg_view)
{
        int preset_num;
        struct cscfg_fs_preset *cfg_fs_preset;
        struct cscfg_config_desc *config_desc = cfg_view->config_desc;
        char name[CONFIGFS_ITEM_NAME_LEN];

        if (!config_desc->nr_presets)
                return 0;

        for (preset_num = 1; preset_num <= config_desc->nr_presets; preset_num++) {
                cfg_fs_preset = devm_kzalloc(cscfg_device(),
                                             sizeof(struct cscfg_fs_preset), GFP_KERNEL);

                if (!cfg_fs_preset)
                        return -ENOMEM;

                snprintf(name, CONFIGFS_ITEM_NAME_LEN, "preset%d", preset_num);
                cfg_fs_preset->preset_num = preset_num;
                cfg_fs_preset->config_desc = cfg_view->config_desc;
                config_group_init_type_name(&cfg_fs_preset->group, name,
                                            &cscfg_config_preset_type);
                configfs_add_default_group(&cfg_fs_preset->group, &cfg_view->group);
        }
        return 0;
}

static struct config_group *cscfg_create_config_group(struct cscfg_config_desc *config_desc)
{
        struct cscfg_fs_config *cfg_view;
        struct device *dev = cscfg_device();
        int err;

        if (!dev)
                return ERR_PTR(-EINVAL);

        cfg_view = devm_kzalloc(dev, sizeof(struct cscfg_fs_config), GFP_KERNEL);
        if (!cfg_view)
                return ERR_PTR(-ENOMEM);

        cfg_view->config_desc = config_desc;
        config_group_init_type_name(&cfg_view->group, config_desc->name, &cscfg_config_view_type);

        /* add in a preset<n> dir for each preset */
        err = cscfg_add_preset_groups(cfg_view);
        if (err)
                return ERR_PTR(err);

        return &cfg_view->group;
}

/* attributes for features view */

static ssize_t cscfg_feat_description_show(struct config_item *item, char *page)
{
        struct cscfg_fs_feature *fs_feat = container_of(to_config_group(item),
                                                        struct cscfg_fs_feature, group);

        return scnprintf(page, PAGE_SIZE, "%s", fs_feat->feat_desc->description);
}
CONFIGFS_ATTR_RO(cscfg_feat_, description);

static ssize_t cscfg_feat_matches_show(struct config_item *item, char *page)
{
        struct cscfg_fs_feature *fs_feat = container_of(to_config_group(item),
                                                        struct cscfg_fs_feature, group);
        u32 match_flags = fs_feat->feat_desc->match_flags;
        int used = 0;

        if (match_flags & CS_CFG_MATCH_CLASS_SRC_ALL)
                used = scnprintf(page, PAGE_SIZE, "SRC_ALL ");

        if (match_flags & CS_CFG_MATCH_CLASS_SRC_ETM4)
                used += scnprintf(page + used, PAGE_SIZE - used, "SRC_ETMV4 ");

        used += scnprintf(page + used, PAGE_SIZE - used, "\n");
        return used;
}
CONFIGFS_ATTR_RO(cscfg_feat_, matches);

static ssize_t cscfg_feat_nr_params_show(struct config_item *item, char *page)
{
        struct cscfg_fs_feature *fs_feat = container_of(to_config_group(item),
                                                        struct cscfg_fs_feature, group);

        return scnprintf(page, PAGE_SIZE, "%d\n", fs_feat->feat_desc->nr_params);
}
CONFIGFS_ATTR_RO(cscfg_feat_, nr_params);

/* base feature desc attrib structures */
static struct configfs_attribute *cscfg_feature_view_attrs[] = {
        &cscfg_feat_attr_description,
        &cscfg_feat_attr_matches,
        &cscfg_feat_attr_nr_params,
        NULL,
};

static const struct config_item_type cscfg_feature_view_type = {
        .ct_owner = THIS_MODULE,
        .ct_attrs = cscfg_feature_view_attrs,
};

static ssize_t cscfg_param_value_show(struct config_item *item, char *page)
{
        struct cscfg_fs_param *param_item = container_of(to_config_group(item),
                                                         struct cscfg_fs_param, group);
        u64 value = param_item->feat_desc->params_desc[param_item->param_idx].value;

        return scnprintf(page, PAGE_SIZE, "0x%llx\n", value);
}

static ssize_t cscfg_param_value_store(struct config_item *item,
                                       const char *page, size_t size)
{
        struct cscfg_fs_param *param_item = container_of(to_config_group(item),
                                                         struct cscfg_fs_param, group);
        struct cscfg_feature_desc *feat_desc = param_item->feat_desc;
        int param_idx = param_item->param_idx;
        u64 value;
        int err;

        err = kstrtoull(page, 0, &value);
        if (!err)
                err = cscfg_update_feat_param_val(feat_desc, param_idx, value);

        return err ? err : size;
}
CONFIGFS_ATTR(cscfg_param_, value);

static struct configfs_attribute *cscfg_param_view_attrs[] = {
        &cscfg_param_attr_value,
        NULL,
};

static const struct config_item_type cscfg_param_view_type = {
        .ct_owner = THIS_MODULE,
        .ct_attrs = cscfg_param_view_attrs,
};

/*
 * configfs has far less functionality provided to add attributes dynamically than sysfs,
 * and the show and store fns pass the enclosing config_item so the actual attribute cannot
 * be determined. Therefore we add each item as a group directory, with a value attribute.
 */
static int cscfg_create_params_group_items(struct cscfg_feature_desc *feat_desc,
                                           struct config_group *params_group)
{
        struct device *dev = cscfg_device();
        struct cscfg_fs_param *param_item;
        int i;

        /* parameter items - as groups with default_value attribute */
        for (i = 0; i < feat_desc->nr_params; i++) {
                param_item = devm_kzalloc(dev, sizeof(struct cscfg_fs_param), GFP_KERNEL);
                if (!param_item)
                        return -ENOMEM;
                param_item->feat_desc = feat_desc;
                param_item->param_idx = i;
                config_group_init_type_name(&param_item->group,
                                            feat_desc->params_desc[i].name,
                                            &cscfg_param_view_type);
                configfs_add_default_group(&param_item->group, params_group);
        }
        return 0;
}

static struct config_group *cscfg_create_feature_group(struct cscfg_feature_desc *feat_desc)
{
        struct cscfg_fs_feature *feat_view;
        struct config_item_type *params_group_type;
        struct config_group *params_group = NULL;
        struct device *dev = cscfg_device();
        int item_err;

        if (!dev)
                return ERR_PTR(-EINVAL);

        feat_view = devm_kzalloc(dev, sizeof(struct cscfg_fs_feature), GFP_KERNEL);
        if (!feat_view)
                return ERR_PTR(-ENOMEM);

        if (feat_desc->nr_params) {
                params_group = devm_kzalloc(dev, sizeof(struct config_group), GFP_KERNEL);
                if (!params_group)
                        return ERR_PTR(-ENOMEM);

                params_group_type = cscfg_create_ci_type();
                if (!params_group_type)
                        return ERR_PTR(-ENOMEM);
        }

        feat_view->feat_desc = feat_desc;
        config_group_init_type_name(&feat_view->group,
                                    feat_desc->name,
                                    &cscfg_feature_view_type);
        if (params_group) {
                config_group_init_type_name(params_group, "params", params_group_type);
                configfs_add_default_group(params_group, &feat_view->group);
                item_err = cscfg_create_params_group_items(feat_desc, params_group);
                if (item_err)
                        return ERR_PTR(item_err);
        }
        return &feat_view->group;
}

static const struct config_item_type cscfg_configs_type = {
        .ct_owner = THIS_MODULE,
};

static struct config_group cscfg_configs_grp = {
        .cg_item = {
                .ci_namebuf = "configurations",
                .ci_type = &cscfg_configs_type,
        },
};

/* add configuration to configurations group */
int cscfg_configfs_add_config(struct cscfg_config_desc *config_desc)
{
        struct config_group *new_group;
        int err;

        new_group = cscfg_create_config_group(config_desc);
        if (IS_ERR(new_group))
                return PTR_ERR(new_group);
        err =  configfs_register_group(&cscfg_configs_grp, new_group);
        if (!err)
                config_desc->fs_group = new_group;
        return err;
}

void cscfg_configfs_del_config(struct cscfg_config_desc *config_desc)
{
        if (config_desc->fs_group) {
                configfs_unregister_group(config_desc->fs_group);
                config_desc->fs_group = NULL;
        }
}

static const struct config_item_type cscfg_features_type = {
        .ct_owner = THIS_MODULE,
};

static struct config_group cscfg_features_grp = {
        .cg_item = {
                .ci_namebuf = "features",
                .ci_type = &cscfg_features_type,
        },
};

/* add feature to features group */
int cscfg_configfs_add_feature(struct cscfg_feature_desc *feat_desc)
{
        struct config_group *new_group;
        int err;

        new_group = cscfg_create_feature_group(feat_desc);
        if (IS_ERR(new_group))
                return PTR_ERR(new_group);
        err =  configfs_register_group(&cscfg_features_grp, new_group);
        if (!err)
                feat_desc->fs_group = new_group;
        return err;
}

void cscfg_configfs_del_feature(struct cscfg_feature_desc *feat_desc)
{
        if (feat_desc->fs_group) {
                configfs_unregister_group(feat_desc->fs_group);
                feat_desc->fs_group = NULL;
        }
}

int cscfg_configfs_init(struct cscfg_manager *cscfg_mgr)
{
        struct configfs_subsystem *subsys;
        struct config_item_type *ci_type;

        if (!cscfg_mgr)
                return -EINVAL;

        ci_type = cscfg_create_ci_type();
        if (!ci_type)
                return -ENOMEM;

        subsys = &cscfg_mgr->cfgfs_subsys;
        config_item_set_name(&subsys->su_group.cg_item, CSCFG_FS_SUBSYS_NAME);
        subsys->su_group.cg_item.ci_type = ci_type;

        config_group_init(&subsys->su_group);
        mutex_init(&subsys->su_mutex);

        /* Add default groups to subsystem */
        config_group_init(&cscfg_configs_grp);
        configfs_add_default_group(&cscfg_configs_grp, &subsys->su_group);

        config_group_init(&cscfg_features_grp);
        configfs_add_default_group(&cscfg_features_grp, &subsys->su_group);

        return configfs_register_subsystem(subsys);
}

void cscfg_configfs_release(struct cscfg_manager *cscfg_mgr)
{
        configfs_unregister_subsystem(&cscfg_mgr->cfgfs_subsys);
}