drivers/hwtracing/coresight/coresight-syscfg-configfs.c - third_party/kernel - Git at Google

 // 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 inline 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 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 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 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 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 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 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);
 }
	// 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 inline 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 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 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 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 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 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 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);
	}