API for individual devices to register with the syscfg management system is added.

Devices register with matching information, and any features or configurations that match will be loaded into the device.

The feature and configuration loading is extended so that on load these are loaded into any currently registered devices. This allows configuration loading after devices have been registered.

Signed-off-by: Mike Leach mike.leach@linaro.org --- .../hwtracing/coresight/coresight-config.h | 98 +++++ .../hwtracing/coresight/coresight-syscfg.c | 348 ++++++++++++++++++ .../hwtracing/coresight/coresight-syscfg.h | 20 + include/linux/coresight.h | 5 + 4 files changed, 471 insertions(+)

diff --git a/drivers/hwtracing/coresight/coresight-config.h b/drivers/hwtracing/coresight/coresight-config.h index 3fedf8ab3cee..75ecdecf7013 100644 --- a/drivers/hwtracing/coresight/coresight-config.h +++ b/drivers/hwtracing/coresight/coresight-config.h @@ -164,4 +164,102 @@ struct cscfg_config_desc { const u64 *presets; /* nr_presets * nr_total_params */ };

+/** + * config register instance - part of a loaded feature. + * maps register values to csdev driver structures + * + * @value: value to use when setting feature on device / store for + * readback of volatile values. + * @drv_store: pointer to internal driver element used to set the value + * in hardware. + */ +struct cscfg_reg_csdev { + struct cscfg_regval_desc value; + void *drv_store; +}; + +/** + * config parameter instance - part of a loaded feature. + * + * @feat: parent feature + * @reg: register value updated by this parameter. + * @current_value: current value of parameter - may be set by user via + * sysfs, or modified during device operation. + * @val64: true if 64 bit value + */ +struct cscfg_parameter_csdev { + struct cscfg_feature_csdev *feat; + struct cscfg_reg_csdev *reg; + u64 current_value; + bool val64; +}; + +/** + * Feature instance loaded into a CoreSight device. + * + * When a feature is loaded into a specific device, then this structure holds + * the connections between the register / parameter values used and the + * internal data structures that are written when the feature is enabled. + * + * Since applying a feature modifies internal data structures in the device, + * then we have a reference to the device spinlock to protect access to these + * structures (@csdev_spinlock). + * + * @desc: pointer to the static descriptor for this feature. + * @csdev: parent CoreSight device instance. + * @node: list entry into feature list for this device. + * @csdev_spinlock: device spinlock from csdev instance.. + * @nr_params: number of parameters. + * @params: current parameter values on this device + * @nr_regs: number of registers to be programmed. + * @regs: Programming details for the registers + */ +struct cscfg_feature_csdev { + const struct cscfg_feature_desc *desc; + struct coresight_device *csdev; + struct list_head node; + spinlock_t *csdev_spinlock; + int nr_params; + struct cscfg_parameter_csdev *params; + int nr_regs; + struct cscfg_reg_csdev *regs; +}; + +/** + * Configuration instance when loaded into a CoreSight device. + * + * The instance contains references to loaded features on this device that are + * used by the configuration. + * + * @desc: reference to the descriptor for this configuration + * @csdev: parent coresight device for this configuration instance. + * @node: list entry within the coresight device + * @nr_feat: Number of features on this device that are used in the + * configuration. + * @feats: reference to the device features to enable. + * @enabled: true if configuration is enabled on this device. + */ +struct cscfg_config_csdev { + const struct cscfg_config_desc *desc; + struct coresight_device *csdev; + struct list_head node; + int nr_feat; + struct cscfg_feature_csdev **feats; + bool enabled; +}; + +/** + * Coresight device operations. + * + * Registered coresight devices provide these operations to manage feature + * instances compatible with the device hardware and drivers + * + * @load_feat: Pass a feature descriptor into the device and create the + * loaded feature instance (struct cscfg_feature_csdev). + */ +struct cscfg_csdev_feat_ops { + int (*load_feat)(struct coresight_device *csdev, + struct cscfg_feature_csdev *feat); +}; + #endif /* _CORESIGHT_CORESIGHT_CONFIG_H */ diff --git a/drivers/hwtracing/coresight/coresight-syscfg.c b/drivers/hwtracing/coresight/coresight-syscfg.c index f7e396a5f9cb..c04cea0c1db2 100644 --- a/drivers/hwtracing/coresight/coresight-syscfg.c +++ b/drivers/hwtracing/coresight/coresight-syscfg.c @@ -25,6 +25,212 @@ static struct cscfg_manager *cscfg_mgr;

/* load features and configuations into the lists */

+/* protect the cfg lists in the csdev instances */ +static DEFINE_MUTEX(cscfg_csdev_mutex); + +/* get name feature instance from a coresight device list of features */ +static struct cscfg_feature_csdev * +cscfg_get_feat_csdev(struct coresight_device *csdev, const char *name) +{ + struct cscfg_feature_csdev *feat = NULL; + + list_for_each_entry(feat, &csdev->feature_csdev_list, node) { + if (strcmp(feat->desc->name, name) == 0) + return feat; + } + return NULL; +} + +/* allocate the device config instance - with max number of used features */ +static struct cscfg_config_csdev * +cscfg_alloc_csdev_cfg(struct coresight_device *csdev, int nr_feats) +{ + struct cscfg_config_csdev *dev_cfg = NULL; + struct device *dev = csdev->dev.parent; + + /* this is being allocated using the devm for the coresight device */ + dev_cfg = devm_kzalloc(dev, sizeof(struct cscfg_config_csdev), GFP_KERNEL); + if (!dev_cfg) + return NULL; + + dev_cfg->csdev = csdev; + dev_cfg->feats = devm_kcalloc(dev, nr_feats, + sizeof(struct cscfg_feature_csdev *), + GFP_KERNEL); + if (!dev_cfg->feats) + dev_cfg = NULL; + return dev_cfg; +} + +/* check match info between used feature from the config and a regisered device */ +static bool cscfg_match_feat_info(struct cscfg_match_desc *used_cmp, + struct cscfg_match_desc *reg_dev) +{ + /* if flags don't match then fail early */ + if (!(used_cmp->match_flags & reg_dev->match_flags)) + return false; + + return true; +} + +/* Load a config into a device if there are feature matches between config and device */ +static int cscfg_add_csdev_cfg(struct coresight_device *csdev, + struct cscfg_match_desc *match_info, + struct cscfg_config_desc *cfg_desc) +{ + struct cscfg_config_csdev *dev_cfg = NULL; + struct cscfg_config_feat_ref *feat_ref; + struct cscfg_feature_csdev *feat; + int checked; + + /* look at each required feature and see if it matches any feature on the device */ + for (checked = 0; checked < cfg_desc->nr_refs; checked++) { + feat_ref = &cfg_desc->refs[checked]; + if (cscfg_match_feat_info(&feat_ref->match, match_info)) { + /* device matched - get the feature */ + feat = cscfg_get_feat_csdev(csdev, feat_ref->name); + if (!feat) + return -EINVAL; + if (!dev_cfg) { + dev_cfg = cscfg_alloc_csdev_cfg(csdev, cfg_desc->nr_refs); + if (!dev_cfg) + return -ENOMEM; + dev_cfg->desc = cfg_desc; + } + dev_cfg->feats[dev_cfg->nr_feat++] = feat; + } + } + /* if matched features, add config to device.*/ + if (dev_cfg) { + mutex_lock(&cscfg_csdev_mutex); + list_add(&dev_cfg->node, &csdev->config_csdev_list); + mutex_unlock(&cscfg_csdev_mutex); + } + + return 0; +} + +/* + * Add the config to the set of registered devices - call with mutex locked. + * Iterates through devices - any device that matches one or more of the + * configuration features will load it, the others will ignore it. + */ +static int cscfg_add_cfg_to_csdevs(struct cscfg_config_desc *cfg_desc) +{ + struct cscfg_csdev_register *curr_item; + int err; + + list_for_each_entry(curr_item, &cscfg_mgr->data.csdev_desc_list, item) { + err = cscfg_add_csdev_cfg(curr_item->csdev, &curr_item->match_info, cfg_desc); + if (err) + return err; + } + return 0; +} + +/* + * Allocate a feature object for load into a csdev. + * memory allocated using the csdev->dev object using devm managed allocator. + */ +static struct cscfg_feature_csdev * +cscfg_alloc_csdev_feat(struct coresight_device *csdev, struct cscfg_feature_desc *feat_desc) +{ + struct cscfg_feature_csdev *feat = NULL; + struct device *dev = csdev->dev.parent; + int i; + + feat = devm_kzalloc(dev, sizeof(struct cscfg_feature_csdev), GFP_KERNEL); + if (!feat) + return NULL; + + /* parameters are optional - could be 0 */ + feat->nr_params = feat_desc->nr_params; + + /* + * if we need parameters, zero alloc the space here, the load routine in + * the csdev device driver will fill out some information according to + * feature descriptor. + */ + if (feat->nr_params) { + feat->params = devm_kcalloc(dev, feat->nr_params, + sizeof(struct cscfg_parameter_csdev), + GFP_KERNEL); + if (!feat->params) + return NULL; + + /* + * fill in the feature reference in the param - other fields + * handled by loader in csdev. + */ + for (i = 0; i < feat->nr_params; i++) + feat->params[i].feat = feat; + } + + /* + * Always have registers to program - again the load routine in csdev device + * will fill out according to feature descriptor and device requirements. + */ + feat->nr_regs = feat_desc->nr_regs; + feat->regs = devm_kcalloc(dev, feat->nr_regs, + sizeof(struct cscfg_reg_csdev), GFP_KERNEL); + if (!feat->regs) + return NULL; + + /* load the feature default values */ + feat->desc = feat_desc; + feat->csdev = csdev; + + return feat; +} + +/* load one feature into one coresight device */ +static int cscfg_load_feat_csdev(struct coresight_device *csdev, + struct cscfg_feature_desc *feat_desc, + struct cscfg_csdev_feat_ops *ops) +{ + struct cscfg_feature_csdev *feat_csdev; + int err; + + if (!ops->load_feat) + return -EINVAL; + + feat_csdev = cscfg_alloc_csdev_feat(csdev, feat_desc); + if (!feat_csdev) + return -ENOMEM; + + /* load the feature into the device - may modify default ops*/ + err = ops->load_feat(csdev, feat_csdev); + if (err) + return err; + + /* add to internal csdev feature list */ + mutex_lock(&cscfg_csdev_mutex); + list_add(&feat_csdev->node, &csdev->feature_csdev_list); + mutex_unlock(&cscfg_csdev_mutex); + + return 0; +} + +/* + * Add feature to any matching devices - call with mutex locked. + * Iterates through devices - any device that matches the feature will be + * called to load it. + */ +static int cscfg_add_feat_to_csdevs(struct cscfg_feature_desc *feat_desc) +{ + struct cscfg_csdev_register *curr_item; + int err; + + list_for_each_entry(curr_item, &cscfg_mgr->data.csdev_desc_list, item) { + if (curr_item->match_info.match_flags & feat_desc->match_flags) { + err = cscfg_load_feat_csdev(curr_item->csdev, feat_desc, &curr_item->ops); + if (err) + return err; + } + } + return 0; +} + /* check feature list for a named feature - call with mutex locked. */ static bool cscfg_match_list_feat(const char *name) { @@ -53,6 +259,13 @@ static int cscfg_check_feat_for_cfg(struct cscfg_config_desc *cfg_desc) */ static int cscfg_load_feat(struct cscfg_feature_desc *feat_desc) { + int err; + + /* add feature to any matching registered devices */ + err = cscfg_add_feat_to_csdevs(feat_desc); + if (err) + return err; + list_add(&feat_desc->item, &cscfg_mgr->data.feat_desc_list);

return 0; @@ -71,6 +284,11 @@ static int cscfg_load_config(struct cscfg_config_desc *cfg_desc) if (err) return err;

+ /* add config to any matching registered device */ + err = cscfg_add_cfg_to_csdevs(cfg_desc); + if (err) + return err; + list_add(&cfg_desc->item, &cscfg_mgr->data.config_desc_list);

return 0; @@ -122,6 +340,136 @@ int cscfg_load_config_sets(struct cscfg_config_desc **cfg_descs, } EXPORT_SYMBOL_GPL(cscfg_load_config_sets);

+/* Handle coresight device registration and add configs and features to devices */ + +/* iterate through config lists and load matching configs to device */ +static int cscfg_add_cfgs_csdev(struct coresight_device *csdev, + struct cscfg_match_desc *info) +{ + struct cscfg_config_desc *curr_item; + int err = 0; + + list_for_each_entry(curr_item, &cscfg_mgr->data.config_desc_list, item) { + err = cscfg_add_csdev_cfg(csdev, info, curr_item); + if (err) + break; + } + return err; +} + +/* iterate through feature lists and load matching features to device */ +static int cscfg_add_feats_csdev(struct coresight_device *csdev, + struct cscfg_match_desc *info, + struct cscfg_csdev_feat_ops *ops) +{ + struct cscfg_feature_desc *curr_item; + int err = 0; + + if (!ops->load_feat) + return -EINVAL; + + list_for_each_entry(curr_item, &cscfg_mgr->data.feat_desc_list, item) { + if (curr_item->match_flags & info->match_flags) { + err = cscfg_load_feat_csdev(csdev, curr_item, ops); + if (err) + break; + } + } + return err; +} + +/* Add coresight device to list and copy its matching info */ +static int cscfg_list_add_csdev(struct coresight_device *csdev, + struct cscfg_match_desc *info, + struct cscfg_csdev_feat_ops *ops) +{ + struct cscfg_csdev_register *list_entry; + + /* allocate the list entry structure */ + list_entry = kzalloc(sizeof(struct cscfg_csdev_register), GFP_KERNEL); + if (!list_entry) + return -ENOMEM; + + list_entry->csdev = csdev; + list_entry->match_info.match_flags = info->match_flags; + list_entry->ops.load_feat = ops->load_feat; + list_add(&list_entry->item, &cscfg_mgr->data.csdev_desc_list); + + INIT_LIST_HEAD(&csdev->feature_csdev_list); + INIT_LIST_HEAD(&csdev->config_csdev_list); + cscfg_mgr->data.nr_csdev++; + + return 0; +} + +/* remove a coresight device from the list and free data */ +static void cscfg_list_remove_csdev(struct coresight_device *csdev) +{ + struct cscfg_csdev_register *curr_item, *tmp; + + list_for_each_entry_safe(curr_item, tmp, &cscfg_mgr->data.csdev_desc_list, item) { + if (curr_item->csdev == csdev) { + list_del(&curr_item->item); + kfree(curr_item); + cscfg_mgr->data.nr_csdev--; + break; + } + } +} + +/* register a coresight device with the syscfg api */ +int cscfg_register_csdev(struct coresight_device *csdev, + struct cscfg_match_desc *info, + struct cscfg_csdev_feat_ops *ops) +{ + int ret = 0; + + mutex_lock(&cscfg_mutex); + + /* add device to list of registered devices */ + ret = cscfg_list_add_csdev(csdev, info, ops); + if (ret) + goto reg_csdev_unlock; + + /* now load any registered features and configs matching the device. */ + ret = cscfg_add_feats_csdev(csdev, info, ops); + if (ret) { + cscfg_list_remove_csdev(csdev); + goto reg_csdev_unlock; + } + + ret = cscfg_add_cfgs_csdev(csdev, info); + if (ret) { + cscfg_list_remove_csdev(csdev); + goto reg_csdev_unlock; + } + + pr_info("CSCFG registered %s", dev_name(&csdev->dev)); + +reg_csdev_unlock: + mutex_unlock(&cscfg_mutex); + return ret; +} +EXPORT_SYMBOL_GPL(cscfg_register_csdev); + +/* remove coresight device and update counts - syscfg device at 0 */ +void cscfg_unregister_csdev(struct coresight_device *csdev) +{ + struct cscfg_csdev_register *curr_item, *tmp; + + mutex_lock(&cscfg_mutex); + list_for_each_entry_safe(curr_item, tmp, &cscfg_mgr->data.csdev_desc_list, item) { + if (curr_item->csdev == csdev) { + list_del(&curr_item->item); + kfree(curr_item); + cscfg_mgr->data.nr_csdev--; + break; + } + } + mutex_unlock(&cscfg_mutex); +} +EXPORT_SYMBOL_GPL(cscfg_unregister_csdev); + /* Initialise system configuration management device. */

struct device *to_device_cscfg(void) diff --git a/drivers/hwtracing/coresight/coresight-syscfg.h b/drivers/hwtracing/coresight/coresight-syscfg.h index 907ba8d3efea..ebf5e1491d86 100644 --- a/drivers/hwtracing/coresight/coresight-syscfg.h +++ b/drivers/hwtracing/coresight/coresight-syscfg.h @@ -26,6 +26,22 @@ struct cscfg_api_data { int nr_csdev; };

+/** + * List entry for Coresight devices that are registered as supporting complex + * config operations. + * + * @csdev: The registered device. + * @match_info: The matching type information. + * @ops: Operations supported by the registered device. + * @item: list entry. + */ +struct cscfg_csdev_register { + struct coresight_device *csdev; + struct cscfg_match_desc match_info; + struct cscfg_csdev_feat_ops ops; + struct list_head item; +}; + /* internal core operations for cscfg */ int __init cscfg_init(void); void __exit cscfg_exit(void); @@ -33,6 +49,10 @@ void __exit cscfg_exit(void); /* syscfg manager external API */ int cscfg_load_config_sets(struct cscfg_config_desc **cfg_descs, struct cscfg_feature_desc **feat_descs); +int cscfg_register_csdev(struct coresight_device *csdev, + struct cscfg_match_desc *info, + struct cscfg_csdev_feat_ops *ops); +void cscfg_unregister_csdev(struct coresight_device *csdev);

/** * System configuration manager device. diff --git a/include/linux/coresight.h b/include/linux/coresight.h index 976ec2697610..d0126ed326a6 100644 --- a/include/linux/coresight.h +++ b/include/linux/coresight.h @@ -219,6 +219,8 @@ struct coresight_sysfs_link { * @nr_links: number of sysfs links created to other components from this * device. These will appear in the "connections" group. * @has_conns_grp: Have added a "connections" group for sysfs links. + * @feature_csdev_list: List of complex feature programming added to the device. + * @config_csdev_list: List of system configurations added to the device. */ struct coresight_device { struct coresight_platform_data *pdata; @@ -240,6 +242,9 @@ struct coresight_device { int nr_links; bool has_conns_grp; bool ect_enabled; /* true only if associated ect device is enabled */ + /* system configuration and feature lists */ + struct list_head feature_csdev_list; + struct list_head config_csdev_list; };

/*

Loaded coresight configurations are registered in the cs_etm\cs_config sub directory. This extends the etm-perf code to handle these registrations, and the cs_syscfg driver to perform the registration on load.

Signed-off-by: Mike Leach mike.leach@linaro.org --- .../hwtracing/coresight/coresight-config.h | 5 +- .../hwtracing/coresight/coresight-etm-perf.c | 164 +++++++++++++++--- .../hwtracing/coresight/coresight-etm-perf.h | 8 + .../hwtracing/coresight/coresight-syscfg.c | 13 +- 4 files changed, 166 insertions(+), 24 deletions(-)

diff --git a/drivers/hwtracing/coresight/coresight-config.h b/drivers/hwtracing/coresight/coresight-config.h index 9d66e0071f38..98380b496046 100644 --- a/drivers/hwtracing/coresight/coresight-config.h +++ b/drivers/hwtracing/coresight/coresight-config.h @@ -154,7 +154,8 @@ struct cscfg_config_feat_ref { * @nr_presets: Number of sets of presets supplied by this configuration. * @nr_total_params: Sum of all parameters declared by used features * @presets: Array of preset values. - * + * @id_ea: Extended attribute for perf configid value + * @event_ea: Extended attribute for perf event value */ struct cscfg_config_desc { const char *name; @@ -165,6 +166,8 @@ struct cscfg_config_desc { int nr_presets; int nr_total_params; const u64 *presets; /* nr_presets * nr_total_params */ + struct dev_ext_attribute *id_ea; + struct dev_ext_attribute *event_ea; };

/** diff --git a/drivers/hwtracing/coresight/coresight-etm-perf.c b/drivers/hwtracing/coresight/coresight-etm-perf.c index a608081bd446..e270bb1e0f7d 100644 --- a/drivers/hwtracing/coresight/coresight-etm-perf.c +++ b/drivers/hwtracing/coresight/coresight-etm-perf.c @@ -18,8 +18,10 @@ #include <linux/types.h> #include <linux/workqueue.h>

+#include "coresight-config.h" #include "coresight-etm-perf.h" #include "coresight-priv.h" +#include "coresight-syscfg.h"

static struct pmu etm_pmu; static bool etm_perf_up; @@ -32,8 +34,13 @@ PMU_FORMAT_ATTR(cycacc, "config:" __stringify(ETM_OPT_CYCACC)); PMU_FORMAT_ATTR(contextid, "config:" __stringify(ETM_OPT_CTXTID)); PMU_FORMAT_ATTR(timestamp, "config:" __stringify(ETM_OPT_TS)); PMU_FORMAT_ATTR(retstack, "config:" __stringify(ETM_OPT_RETSTK)); +/* preset - if sink ID is used as a configuration selector */ +PMU_FORMAT_ATTR(preset, "config:0-3"); /* Sink ID - same for all ETMs */ PMU_FORMAT_ATTR(sinkid, "config2:0-31"); +/* config ID - set if a system configuration is selected */ +PMU_FORMAT_ATTR(configid, "config2:32-63"); +

static struct attribute *etm_config_formats_attr[] = { &format_attr_cycacc.attr, @@ -41,6 +48,8 @@ static struct attribute *etm_config_formats_attr[] = { &format_attr_timestamp.attr, &format_attr_retstack.attr, &format_attr_sinkid.attr, + &format_attr_preset.attr, + &format_attr_configid.attr, NULL, };

@@ -58,9 +67,29 @@ static const struct attribute_group etm_pmu_sinks_group = { .attrs = etm_config_sinks_attr, };

+static struct attribute *etm_config_cscfg_attr[] = { + NULL, +}; + +static const struct attribute_group etm_pmu_cscfg_group = { + .name = "configurations", + .attrs = etm_config_cscfg_attr, +}; + +static struct attribute *etm_config_events_attr[] = { + NULL, +}; + +static const struct attribute_group etm_pmu_events_group = { + .name = "events", + .attrs = etm_config_events_attr, +}; + static const struct attribute_group *etm_pmu_attr_groups[] = { &etm_pmu_format_group, &etm_pmu_sinks_group, + &etm_pmu_cscfg_group, + &etm_pmu_events_group, NULL, };

@@ -219,7 +248,7 @@ static void *etm_setup_aux(struct perf_event *event, void **pages, INIT_WORK(&event_data->work, free_event_data);

/* First get the selected sink from user space. */ - if (event->attr.config2) { + if (event->attr.config2 & GENMASK_ULL(31, 0)) { id = (u32)event->attr.config2; sink = coresight_get_sink_by_id(id); } @@ -537,21 +566,17 @@ static ssize_t etm_perf_sink_name_show(struct device *dev, return scnprintf(buf, PAGE_SIZE, "0x%lx\n", (unsigned long)(ea->var)); }

-int etm_perf_add_symlink_sink(struct coresight_device *csdev) +int etm_perf_add_symlink_group(struct device *dev, + struct dev_ext_attribute **ext_attr, + const char *name, + const char *group_name) { - int ret; + struct dev_ext_attribute *ea; unsigned long hash; - const char *name; + int ret; struct device *pmu_dev = etm_pmu.dev; - struct device *dev = &csdev->dev; - struct dev_ext_attribute *ea;

- if (csdev->type != CORESIGHT_DEV_TYPE_SINK && - csdev->type != CORESIGHT_DEV_TYPE_LINKSINK) - return -EINVAL; - - if (csdev->ea != NULL) - return -EINVAL; + *ext_attr = NULL;

if (!etm_perf_up) return -EPROBE_DEFER; @@ -560,7 +585,6 @@ int etm_perf_add_symlink_sink(struct coresight_device *csdev) if (!ea) return -ENOMEM;

- name = dev_name(dev); /* See function coresight_get_sink_by_id() to know where this is used */ hash = hashlen_hash(hashlen_string(NULL, name));

@@ -574,31 +598,127 @@ int etm_perf_add_symlink_sink(struct coresight_device *csdev) ea->var = (unsigned long *)hash;

ret = sysfs_add_file_to_group(&pmu_dev->kobj, - &ea->attr.attr, "sinks"); - + &ea->attr.attr, group_name); if (!ret) - csdev->ea = ea; - + *ext_attr = ea; return ret; }

-void etm_perf_del_symlink_sink(struct coresight_device *csdev) +int etm_perf_add_symlink_sink(struct coresight_device *csdev) +{ + const char *name; + struct device *dev = &csdev->dev; + + if (csdev->type != CORESIGHT_DEV_TYPE_SINK && + csdev->type != CORESIGHT_DEV_TYPE_LINKSINK) + return -EINVAL; + + if (csdev->ea != NULL) + return -EINVAL; + + name = dev_name(dev); + return etm_perf_add_symlink_group(dev, &csdev->ea, name, "sinks"); +} + +void etm_perf_del_symlink_group(struct dev_ext_attribute *ea, const char *group_name) { struct device *pmu_dev = etm_pmu.dev; - struct dev_ext_attribute *ea = csdev->ea;

+ sysfs_remove_file_from_group(&pmu_dev->kobj, + &ea->attr.attr, group_name); +} + +void etm_perf_del_symlink_sink(struct coresight_device *csdev) +{ if (csdev->type != CORESIGHT_DEV_TYPE_SINK && csdev->type != CORESIGHT_DEV_TYPE_LINKSINK) return;

- if (!ea) + if (!csdev->ea) return;

- sysfs_remove_file_from_group(&pmu_dev->kobj, - &ea->attr.attr, "sinks"); + etm_perf_del_symlink_group(csdev->ea, "sinks"); csdev->ea = NULL; }

+/* string to contain the attribute value */ +#define CSCFG_EVENT_STR_SIZE 32 + +static ssize_t etm_perf_cscfg_event_show(struct device *dev, + struct device_attribute *dattr, + char *buf) +{ + struct dev_ext_attribute *ea; + + ea = container_of(dattr, struct dev_ext_attribute, attr); + return scnprintf(buf, PAGE_SIZE, "%s\n", (const char *)(ea->var)); +} + +static int etm_perf_add_cscfg_event(struct device *dev, struct cscfg_config_desc *cs_cfg) +{ + struct dev_ext_attribute *ea; + unsigned long hash; + int ret; + struct device *pmu_dev = etm_pmu.dev; + + ea = devm_kzalloc(dev, sizeof(*ea), GFP_KERNEL); + if (!ea) + return -ENOMEM; + + hash = (unsigned long)cs_cfg->id_ea->var; + + sysfs_attr_init(&ea->attr.attr); + ea->attr.attr.name = devm_kstrdup(dev, cs_cfg->name, GFP_KERNEL); + if (!ea->attr.attr.name) + return -ENOMEM; + + /* + * attribute value is "configid=<hash>". + * this will be what perf evaluates when the config name is used + * on the command line. + */ + ea->var = devm_kzalloc(dev, CSCFG_EVENT_STR_SIZE, GFP_KERNEL); + if (!ea->var) + return -ENOMEM; + + scnprintf(ea->var, CSCFG_EVENT_STR_SIZE, "configid=0x%lx", hash); + ea->attr.attr.mode = 0444; + ea->attr.show = etm_perf_cscfg_event_show; + + ret = sysfs_add_file_to_group(&pmu_dev->kobj, + &ea->attr.attr, "events"); + if (!ret) + cs_cfg->event_ea = ea; + return ret; +} + +int etm_perf_add_symlink_cscfg(struct device *dev, struct cscfg_config_desc *cs_cfg) +{ + int err; + + if (cs_cfg->id_ea != NULL) + return 0; + + err = etm_perf_add_symlink_group(dev, &cs_cfg->id_ea, + cs_cfg->name, "configurations"); + + if (!err) + err = etm_perf_add_cscfg_event(dev, cs_cfg); + + return err; +} + +void etm_perf_del_symlink_cscfg(struct cscfg_config_desc *cs_cfg) +{ + if (!cs_cfg->id_ea) + return; + + etm_perf_del_symlink_group(cs_cfg->id_ea, "configurations"); + etm_perf_del_symlink_group(cs_cfg->event_ea, "events"); + cs_cfg->id_ea = NULL; + cs_cfg->event_ea = NULL; +} + int __init etm_perf_init(void) { int ret; diff --git a/drivers/hwtracing/coresight/coresight-etm-perf.h b/drivers/hwtracing/coresight/coresight-etm-perf.h index 29d90dfeba31..3646a3837a0b 100644 --- a/drivers/hwtracing/coresight/coresight-etm-perf.h +++ b/drivers/hwtracing/coresight/coresight-etm-perf.h @@ -11,6 +11,7 @@ #include "coresight-priv.h"

struct coresight_device; +struct cscfg_config_desc;

/* * In both ETMv3 and v4 the maximum number of address comparator implentable @@ -69,6 +70,9 @@ static inline void *etm_perf_sink_config(struct perf_output_handle *handle) return data->snk_config; return NULL; } +int etm_perf_add_symlink_cscfg(struct device *dev, + struct cscfg_config_desc *cscfg_desc); +void etm_perf_del_symlink_cscfg(struct cscfg_config_desc *cscfg_desc); #else static inline int etm_perf_symlink(struct coresight_device *csdev, bool link) { return -EINVAL; } @@ -79,6 +83,10 @@ static inline void *etm_perf_sink_config(struct perf_output_handle *handle) { return NULL; } +int etm_perf_add_symlink_cscfg(struct device *dev, + struct cscfg_config_desc *cscfg_desc) +{ return -EINVAL; } +void etm_perf_del_symlink_cscfg(struct cscfg_config_desc *cscfg_desc) {}

#endif /* CONFIG_CORESIGHT */

diff --git a/drivers/hwtracing/coresight/coresight-syscfg.c b/drivers/hwtracing/coresight/coresight-syscfg.c index 4b8e4e35e3e7..a070f135eca3 100644 --- a/drivers/hwtracing/coresight/coresight-syscfg.c +++ b/drivers/hwtracing/coresight/coresight-syscfg.c @@ -7,6 +7,7 @@ #include <linux/platform_device.h>

#include "coresight-config.h" +#include "coresight-etm-perf.h" #include "coresight-syscfg.h"

/* @@ -100,6 +101,7 @@ static int cscfg_add_csdev_cfg(struct coresight_device *csdev, dev_cfg->feats[dev_cfg->nr_feat++] = feat; } } + /* if matched features, add config to device.*/ if (dev_cfg) { mutex_lock(&cscfg_csdev_mutex); @@ -290,8 +292,12 @@ static int cscfg_load_config(struct cscfg_config_desc *cfg_desc) if (err) return err;

- list_add(&cfg_desc->item, &cscfg_mgr->data.config_desc_list); + /* add config to perf fs to allow selection */ + err = etm_perf_add_symlink_cscfg(to_device_cscfg(), cfg_desc); + if (err) + return err;

+ list_add(&cfg_desc->item, &cscfg_mgr->data.config_desc_list); return 0; }

@@ -517,7 +523,12 @@ int cscfg_create_device(void)

void cscfg_clear_device(void) { + struct cscfg_config_desc *cfg_desc; + mutex_lock(&cscfg_mutex); + list_for_each_entry(cfg_desc, &cscfg_mgr->data.config_desc_list, item) { + etm_perf_del_symlink_cscfg(cfg_desc); + } device_unregister(to_device_cscfg()); mutex_unlock(&cscfg_mutex); }

Add calls to activate the selected configuration as perf starts and stops the tracing session.

Signed-off-by: Mike Leach mike.leach@linaro.org --- drivers/hwtracing/coresight/coresight-etm-perf.c | 14 +++++++++++++- drivers/hwtracing/coresight/coresight-etm-perf.h | 2 ++ 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/drivers/hwtracing/coresight/coresight-etm-perf.c b/drivers/hwtracing/coresight/coresight-etm-perf.c index e270bb1e0f7d..5c1aeddabc59 100644 --- a/drivers/hwtracing/coresight/coresight-etm-perf.c +++ b/drivers/hwtracing/coresight/coresight-etm-perf.c @@ -178,6 +178,10 @@ static void free_event_data(struct work_struct *work) /* Free the sink buffers, if there are any */ free_sink_buffer(event_data);

+ /* clear any configuration we were using */ + if (event_data->config_id_hash) + cscfg_deactivate_config(event_data->config_id_hash); + for_each_cpu(cpu, mask) { struct list_head **ppath;

@@ -236,7 +240,7 @@ static void etm_free_aux(void *data) static void *etm_setup_aux(struct perf_event *event, void **pages, int nr_pages, bool overwrite) { - u32 id; + u32 id, config_id; int cpu = event->cpu; cpumask_t *mask; struct coresight_device *sink = NULL; @@ -253,6 +257,14 @@ static void *etm_setup_aux(struct perf_event *event, void **pages, sink = coresight_get_sink_by_id(id); }

+ /* check if user wants a coresight configuration selected */ + config_id = (u32)((event->attr.config2 & GENMASK_ULL(63, 32)) >> 32); + if (config_id) { + if (cscfg_activate_config(config_id)) + goto err; + event_data->config_id_hash = config_id; + } + mask = &event_data->mask;

/* diff --git a/drivers/hwtracing/coresight/coresight-etm-perf.h b/drivers/hwtracing/coresight/coresight-etm-perf.h index 3646a3837a0b..751d768939d8 100644 --- a/drivers/hwtracing/coresight/coresight-etm-perf.h +++ b/drivers/hwtracing/coresight/coresight-etm-perf.h @@ -49,12 +49,14 @@ struct etm_filters { * @work: Handle to free allocated memory outside IRQ context. * @mask: Hold the CPU(s) this event was set for. * @snk_config: The sink configuration. + * @config_id_hash: The id of any coresight config selected. * @path: An array of path, each slot for one CPU. */ struct etm_event_data { struct work_struct work; cpumask_t mask; void *snk_config; + u32 config_id_hash; struct list_head * __percpu *path; };

Preload set of configurations.

This patch creates a small set of preloaded configurations and features that are available immediately after coresight has been initialised.

The current set provides a strobing feature for ETMv4, that creates a periodic sampling of trace by switching trace generation on and off using counters in the ETM.

A configuration called "autofdo" is also provided that uses the 'strobing' feature and provides a couple of preset values, selectable on the perf command line.

Signed-off-by: Mike Leach mike.leach@linaro.org --- drivers/hwtracing/coresight/Makefile | 3 +- .../hwtracing/coresight/coresight-cfg-afdo.c | 154 ++++++++++++++++++ .../coresight/coresight-cfg-preload.c | 25 +++ .../coresight/coresight-cfg-preload.h | 11 ++ drivers/hwtracing/coresight/coresight-core.c | 6 + .../hwtracing/coresight/coresight-syscfg.h | 1 + 6 files changed, 199 insertions(+), 1 deletion(-) create mode 100644 drivers/hwtracing/coresight/coresight-cfg-afdo.c create mode 100644 drivers/hwtracing/coresight/coresight-cfg-preload.c create mode 100644 drivers/hwtracing/coresight/coresight-cfg-preload.h

diff --git a/drivers/hwtracing/coresight/Makefile b/drivers/hwtracing/coresight/Makefile index ea544206204d..2707bfef1b76 100644 --- a/drivers/hwtracing/coresight/Makefile +++ b/drivers/hwtracing/coresight/Makefile @@ -4,7 +4,8 @@ # obj-$(CONFIG_CORESIGHT) += coresight.o coresight-y := coresight-core.o coresight-etm-perf.o coresight-platform.o \ - coresight-sysfs.o coresight-syscfg.o coresight-config.o + coresight-sysfs.o coresight-syscfg.o coresight-config.o \ + coresight-cfg-preload.o coresight-cfg-afdo.o obj-$(CONFIG_CORESIGHT_LINK_AND_SINK_TMC) += coresight-tmc.o coresight-tmc-y := coresight-tmc-core.o coresight-tmc-etf.o \ coresight-tmc-etr.o diff --git a/drivers/hwtracing/coresight/coresight-cfg-afdo.c b/drivers/hwtracing/coresight/coresight-cfg-afdo.c new file mode 100644 index 000000000000..ff69fb3f4434 --- /dev/null +++ b/drivers/hwtracing/coresight/coresight-cfg-afdo.c @@ -0,0 +1,154 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright(C) 2020 Linaro Limited. All rights reserved. + * Author: Mike Leach mike.leach@linaro.org + */ + +#include "coresight-config.h" +#include "coresight-etm4x-cfg.h" + +/* preload configurations and features */ + +/* preload in features for ETMv4 */ + +/* strobe feature */ +static struct cscfg_parameter_desc strobe_params[] = { + { + .name = "window", + .value = 5000, + }, + { + .name = "period", + .value = 10000, + }, +}; + +static struct cscfg_regval_desc strobe_regs[] = { + /* resource selectors */ + { + .type = CS_CFG_REG_TYPE_RESOURCE, + .offset = TRCRSCTLRn(2), + .hw_info = ETM4_CFG_RES_SEL, + .val32 = 0x20001, + }, + { + .type = CS_CFG_REG_TYPE_RESOURCE, + .offset = TRCRSCTLRn(3), + .hw_info = ETM4_CFG_RES_SEQ, + .val32 = 0x20002, + }, + /* strobe window counter 0 - reload from param 0 */ + { + .type = CS_CFG_REG_TYPE_RESOURCE | CS_CFG_REG_TYPE_VAL_SAVE, + .offset = TRCCNTVRn(0), + .hw_info = ETM4_CFG_RES_CTR, + }, + { + .type = CS_CFG_REG_TYPE_RESOURCE | CS_CFG_REG_TYPE_VAL_PARAM, + .offset = TRCCNTRLDVRn(0), + .hw_info = ETM4_CFG_RES_CTR, + .val32 = 0, + }, + { + .type = CS_CFG_REG_TYPE_RESOURCE, + .offset = TRCCNTCTLRn(0), + .hw_info = ETM4_CFG_RES_CTR, + .val32 = 0x10001, + }, + /* strobe period counter 1 - reload from param 1 */ + { + .type = CS_CFG_REG_TYPE_RESOURCE | CS_CFG_REG_TYPE_VAL_SAVE, + .offset = TRCCNTVRn(1), + .hw_info = ETM4_CFG_RES_CTR, + }, + { + .type = CS_CFG_REG_TYPE_RESOURCE | CS_CFG_REG_TYPE_VAL_PARAM, + .offset = TRCCNTRLDVRn(1), + .hw_info = ETM4_CFG_RES_CTR, + .val32 = 1, + }, + { + .type = CS_CFG_REG_TYPE_RESOURCE, + .offset = TRCCNTCTLRn(1), + .hw_info = ETM4_CFG_RES_CTR, + .val32 = 0x8102, + }, + /* sequencer */ + { + .type = CS_CFG_REG_TYPE_RESOURCE, + .offset = TRCSEQEVRn(0), + .hw_info = ETM4_CFG_RES_SEQ, + .val32 = 0x0081, + }, + { + .type = CS_CFG_REG_TYPE_RESOURCE, + .offset = TRCSEQEVRn(1), + .hw_info = ETM4_CFG_RES_SEQ, + .val32 = 0x0000, + }, + /* view-inst */ + { + .type = CS_CFG_REG_TYPE_STD | CS_CFG_REG_TYPE_VAL_MASK, + .offset = TRCVICTLR, + .val32 = 0x0003, + .mask32 = 0x0003, + }, + /* end of regs */ +}; + +struct cscfg_feature_desc strobe = { + .name = "strobing", + .brief = "Generate periodic trace capture windows.\n" + "parameter 'window': a number of CPU cycles (W)\n" + "parameter 'period': trace enabled for W cycles every period x W cycles\n", + .match_flags = CS_CFG_MATCH_CLASS_SRC_ETM4, + .nr_params = ARRAY_SIZE(strobe_params), + .params = strobe_params, + .nr_regs = ARRAY_SIZE(strobe_regs), + .regs = strobe_regs, +}; + +/* create an autofdo configuration */ + +/* we will provide 9 sets of preset parameter values */ +#define AFDO_NR_PRESETS 9 +/* the total number of parameters in used features */ +#define AFDO_NR_PARAM_SUM ARRAY_SIZE(strobe_params) + +#define AFDO_MATCH_STROBING (CS_CFG_MATCH_INST_ANY | CS_CFG_MATCH_CLASS_SRC_ETM4) + +static struct cscfg_config_feat_ref afdo_refs[] = { + { + .name = "strobing", + .match = { + .match_flags = AFDO_MATCH_STROBING, + }, + }, +}; + +/* + * set of presets leaves strobing window constant while varying period to allow + * experimentation with mark / space ratios for various workloads + */ +static u64 afdo_presets[AFDO_NR_PRESETS][AFDO_NR_PARAM_SUM] = { + { 5000, 2 }, + { 5000, 4 }, + { 5000, 8 }, + { 5000, 16 }, + { 5000, 64 }, + { 5000, 128 }, + { 5000, 512 }, + { 5000, 1024 }, + { 5000, 4096 }, +}; + +struct cscfg_config_desc afdo = { + .name = "autofdo", + .brief = "Setup ETMs with strobing for autofdo\n" + "Supplied presets allow experimentation with mark-space ratio for various loads\n", + .nr_refs = ARRAY_SIZE(afdo_refs), + .refs = afdo_refs, + .nr_presets = AFDO_NR_PRESETS, + .nr_total_params = AFDO_NR_PARAM_SUM, + .presets = &afdo_presets[0][0], +}; diff --git a/drivers/hwtracing/coresight/coresight-cfg-preload.c b/drivers/hwtracing/coresight/coresight-cfg-preload.c new file mode 100644 index 000000000000..c7ec5cbdd990 --- /dev/null +++ b/drivers/hwtracing/coresight/coresight-cfg-preload.c @@ -0,0 +1,25 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright(C) 2020 Linaro Limited. All rights reserved. + * Author: Mike Leach mike.leach@linaro.org + */ + +#include "coresight-cfg-preload.h" +#include "coresight-config.h" +#include "coresight-syscfg.h" + +static struct cscfg_feature_desc *preload_feats[] = { + &strobe, + 0 +}; + +static struct cscfg_config_desc *preload_cfgs[] = { + &afdo, + 0 +}; + +/* preload called with mutex locked */ +int cscfg_preload(void) +{ + return cscfg_load_config_sets(preload_cfgs, preload_feats); +} diff --git a/drivers/hwtracing/coresight/coresight-cfg-preload.h b/drivers/hwtracing/coresight/coresight-cfg-preload.h new file mode 100644 index 000000000000..fc4ac7faa93d --- /dev/null +++ b/drivers/hwtracing/coresight/coresight-cfg-preload.h @@ -0,0 +1,11 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright(C) 2020 Linaro Limited. All rights reserved. + * Author: Mike Leach mike.leach@linaro.org + */ + +/* declare preloaded configurations and features */ + +/* from coresight-cfg-afdo.c */ +extern struct cscfg_feature_desc strobe; +extern struct cscfg_config_desc afdo; diff --git a/drivers/hwtracing/coresight/coresight-core.c b/drivers/hwtracing/coresight/coresight-core.c index 6bd41de46648..633ddcffc6c7 100644 --- a/drivers/hwtracing/coresight/coresight-core.c +++ b/drivers/hwtracing/coresight/coresight-core.c @@ -1744,9 +1744,15 @@ static int __init coresight_init(void)

/* initialise the coresight syscfg API */ ret = cscfg_init(); + if (ret) + goto exit_perf_close; + + /* preload builtin configurations */ + ret = cscfg_preload(); if (!ret) return 0;

+exit_perf_close: etm_perf_exit(); exit_bus_unregister: bus_unregister(&coresight_bustype); diff --git a/drivers/hwtracing/coresight/coresight-syscfg.h b/drivers/hwtracing/coresight/coresight-syscfg.h index 301e26e1e98f..a8a6b21315d8 100644 --- a/drivers/hwtracing/coresight/coresight-syscfg.h +++ b/drivers/hwtracing/coresight/coresight-syscfg.h @@ -47,6 +47,7 @@ struct cscfg_csdev_register { /* internal core operations for cscfg */ int __init cscfg_init(void); void __exit cscfg_exit(void); +int cscfg_preload(void);

/* syscfg manager external API */ int cscfg_load_config_sets(struct cscfg_config_desc **cfg_descs,

Adds documentation for the CoreSight System configuration manager.

Signed-off-by: Mike Leach mike.leach@linaro.org --- .../trace/coresight/coresight-config.rst | 244 ++++++++++++++++++ Documentation/trace/coresight/coresight.rst | 16 ++ 2 files changed, 260 insertions(+) create mode 100644 Documentation/trace/coresight/coresight-config.rst

diff --git a/Documentation/trace/coresight/coresight-config.rst b/Documentation/trace/coresight/coresight-config.rst new file mode 100644 index 000000000000..3a4aa7bfa131 --- /dev/null +++ b/Documentation/trace/coresight/coresight-config.rst @@ -0,0 +1,244 @@ +.. SPDX-License-Identifier: GPL-2.0 + +====================================== +CoreSight System Configuration Manager +====================================== + + :Author: Mike Leach mike.leach@linaro.org + :Date: October 2020 + +Introduction +============ + +The CoreSight System Configuration manager is an API that allows the +programming of the CoreSight system with pre-defined configurations that +can then be easily enabled from sysfs or perf. + +Many CoreSight components can be programmed in complex ways - especially ETMs. +In addition, components can interact across the CoreSight system, often via +the cross trigger components such as CTI and CTM. These system settings can +be defined and enabled as named configurations. + + +Basic Concepts +============== + +This section introduces the basic concepts of a CoreSight system configuration. + + +Features +-------- + +A feature is a named set of programming for a CoreSight device. The programming +is device dependent, and can be defined in terms of absolute register values, +resource usage and parameter values. + +The feature is defined using a descriptor. This descriptor is used to load onto +a matching device, either when the feature is loaded into the system, or when the +CoreSight device is registered with the configuration manager. + +The load process involves interpreting the descriptor into a set of register +accesses in the driver - the resource usage and parameter descriptions +translated into appropriate register accesses. This interpretation makes it easy +and efficient for the feature to be programmed onto the device when required. + +The feature will not be active on the device until the feature is enabled, and +the device itself is enabled. When the device is enabled then enabled features +will be programmed into the device hardware. + +A feature is enabled as part of a configuration being enabled on the system. + + +Parameter Value +~~~~~~~~~~~~~~~ + +A parameter value is a named value that may be set by the user prior to the +feature being enabled that can adjust the behaviour of the operation programmed +by the feature. + +For example, this could be a count value in a programmed operation that repeats +at a given rate. When the feature is enabled then the current value of the +parameter is used in programming the device. + +The feature descriptor defines a default value for a parameter, which is used +if the user does not supply a new value. + +Users can update parameter values using the configfs API for the CoreSight +system - which is described below. + +The current value of the parameter is loaded into the device when the feature +is enabled on that device. + + +Configurations +-------------- + +A configuration defines a set of features that are to be used in a trace +session where the configuration is selected. For any trace session only one +configuration may be selected. + +The features defined may be on any type of device that is registered +to support system configuration. A configuration may select features to be +enabled on a class of devices - i.e. any ETMv4, or specific devices, e.g. a +specific CTI on the system. + +As with the feature, a descriptor is used to define the configuration. +This will define the features that must be enabled as part of the configuration +as well as any preset values that can be used to override default parameter +values. + + +Preset Values +~~~~~~~~~~~~~ + +Preset values are easily selectable sets of parameter values for the features +that the configuration uses. The number of values in a single preset set, equals +the sum of parameter values in the features used by the configuration. + +e.g. a configuration consists of 3 features, one has 2 parameters, one has +a single parameter, and another has no parameters. A single preset set will +therefore have 3 values. + +Presets are optionally defined by the configuration, up to 15 can be defined. +If no preset is selected, then the parameter values defined in the feature +are used as normal. + + +Operation +~~~~~~~~~ + +The following steps take place in the operation of a configuration. + +1) In this example, the configuration is 'autofdo', which has an + associated feature 'strobing' that works on ETMv4 CoreSight Devices. + +2) The configuration is enabled. For example 'perf' may select the + configuration as part of its command line:: + + perf record -e cs_etm/autofdo/ myapp + + which will enable the 'autofdo' configuration. + +3) perf starts tracing on the system. As each ETMv4 that perf uses for + trace is enabled, the configuration manager will check if the ETMv4 + has a feature that relates to the currently active configuration. + In this case 'strobing' is enabled & programmed into the ETMv4. + +4) When the ETMv4 is disabled, any registers marked as needing to be + saved will be read back. + +5) At the end of the perf session, the configuration will be disabled. + + +Viewing Configurations and Features +=================================== + +The set of configurations and features that are currently loaded into the +system can be viewed using the configfs API. + +Mount configfs as normal and the 'coresight-syscfg' subsystem will appear:: + + $ ls /config + coresight-syscfg stp-policy + +This has two sub-directories:: + + $ cd coresight-syscfg/ + $ ls + configurations features + +The system has the configuration 'autofdo' built in. It may be examined as +follows:: + + $ cd configurations/ + $ ls + autofdo + $ cd autofdo/ + $ ls + description preset1 preset3 preset5 preset7 preset9 + feature_refs preset2 preset4 preset6 preset8 + $ cat description + Setup ETMs with strobing for autofdo + $ cat feature_refs + strobing + +Each preset declared has a preset<n> subdirectory declared. The values for +the preset can be examined:: + + $ cat preset1/values + strobing.window = 0x1388 strobing.period = 0x2 + $ cat preset2/values + strobing.window = 0x1388 strobing.period = 0x4 + +The features referenced by the configuration can be examined in the features +directory:: + + $ cd ../../features/strobing/ + $ ls + description matches nr_params params + $ cat description + Generate periodic trace capture windows. + parameter 'window': a number of CPU cycles (W) + parameter 'period': trace enabled for W cycles every period x W cycles + $ cat matches + SRC_ETMV4 + $ cat nr_params + 2 + +Move to the params directory to examine and adjust parameters:: + + cd params + $ ls + period window + $ cd period + $ ls + value + $ cat value + 0x2710 + # echo 15000 > value + # cat value + 0x3a98 + +Parameters adjusted in this way are reflected in all device instances that have +loaded the feature. + + +Using Configurations in perf +============================ + +The configurations loaded into the CoreSight configuration management are +also declared in the perf 'cs_etm' event infrastructure so that they can +be selected when running trace under perf:: + + $ ls /sys/devices/cs_etm + configurations format perf_event_mux_interval_ms sinks type + events nr_addr_filters power + +Key directories here are 'configurations' - which lists the loaded +configurations, and 'events' - a generic perf directory which allows +selection on the perf command line.:: + + $ ls configurations/ + autofdo + $ cat configurations/autofdo + 0xa7c3dddd + +As with the sinks entries, this provides a hash of the configuration name. +The entry in the 'events' directory uses perfs built in syntax generator +to substitute the syntax for the name when evaluating the command:: + + $ ls events/ + autofdo + $ cat events/autofdo + configid=0xa7c3dddd + +The 'autofdo' configuration may be selected on the perf command line:: + + $ perf record -e cs_etm/autofdo/u --per-thread <application> + +A preset to override the current parameter values can also be selected:: + + $ perf record -e cs_etm/autofdo,preset=1/u --per-thread <application> + +When configurations are selected in this way, then the trace sink used is +automatically selected. diff --git a/Documentation/trace/coresight/coresight.rst b/Documentation/trace/coresight/coresight.rst index 0b73acb44efa..0122d9bebf35 100644 --- a/Documentation/trace/coresight/coresight.rst +++ b/Documentation/trace/coresight/coresight.rst @@ -587,6 +587,20 @@ A separate documentation file is provided to explain the use of these devices. (:doc:`coresight-ect`) [#fourth]_.

+CoreSight System Configuration +------------------------------ + +CoreSight components can be complex devices with many programming options. +Furthermore, components can be programmed to interact with each other across the +complete system. + +A CoreSight System Configuration manager is provided to allow these complex programming +configurations to be selected and used easily from perf and sysfs. + +See the separate document for further information. +(:doc:`coresight-config`) [#fifth]_. + + .. [#first] Documentation/ABI/testing/sysfs-bus-coresight-devices-stm

.. [#second] Documentation/trace/stm.rst @@ -594,3 +608,5 @@ A separate documentation file is provided to explain the use of these devices. .. [#third] https://github.com/Linaro/perf-opencsd

.. [#fourth] Documentation/trace/coresight/coresight-ect.rst + +.. [#fifth] Documentation/trace/coresight/coresight-config.rst

On Thu, Jan 28, 2021 at 05:09:27PM +0000, Mike Leach wrote:

Creates an system management API to allow complex configurations and features to be programmed into a CoreSight infrastructure.

A feature is defined as a programming set for a device or class of devices.

A configuration is a set of features across the system that are enabled for a trace session.

The API will manage system wide configuration, and allow complex programmed features to be added to individual device instances, and provide for system wide configuration selection on trace capture operations.

This patch creates the initial data object and the initial API for loading configurations and features.

Signed-off-by: Mike Leach mike.leach@linaro.org

drivers/hwtracing/coresight/Makefile | 2 +- .../hwtracing/coresight/coresight-config.h | 167 +++++++++++++++ drivers/hwtracing/coresight/coresight-core.c | 12 +- .../hwtracing/coresight/coresight-etm-perf.c | 2 +- .../hwtracing/coresight/coresight-etm-perf.h | 2 +- .../hwtracing/coresight/coresight-syscfg.c | 197 ++++++++++++++++++ .../hwtracing/coresight/coresight-syscfg.h | 54 +++++ 7 files changed, 432 insertions(+), 4 deletions(-) create mode 100644 drivers/hwtracing/coresight/coresight-config.h create mode 100644 drivers/hwtracing/coresight/coresight-syscfg.c create mode 100644 drivers/hwtracing/coresight/coresight-syscfg.h

diff --git a/drivers/hwtracing/coresight/Makefile b/drivers/hwtracing/coresight/Makefile index f20e357758d1..4ce854c434b1 100644 --- a/drivers/hwtracing/coresight/Makefile +++ b/drivers/hwtracing/coresight/Makefile @@ -4,7 +4,7 @@ # obj-$(CONFIG_CORESIGHT) += coresight.o coresight-y := coresight-core.o coresight-etm-perf.o coresight-platform.o \

• coresight-sysfs.o
  

• coresight-sysfs.o coresight-syscfg.o
  

obj-$(CONFIG_CORESIGHT_LINK_AND_SINK_TMC) += coresight-tmc.o coresight-tmc-y := coresight-tmc-core.o coresight-tmc-etf.o \ coresight-tmc-etr.o diff --git a/drivers/hwtracing/coresight/coresight-config.h b/drivers/hwtracing/coresight/coresight-config.h new file mode 100644 index 000000000000..3fedf8ab3cee --- /dev/null +++ b/drivers/hwtracing/coresight/coresight-config.h @@ -0,0 +1,167 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/*

• • Copyright (c) 2020 Linaro Limited, All rights reserved.
• • Author: Mike Leach mike.leach@linaro.org
• */

+#ifndef _CORESIGHT_CORESIGHT_CONFIG_H +#define _CORESIGHT_CORESIGHT_CONFIG_H

+#include <linux/coresight.h> +#include <linux/types.h>

+/* CoreSight Configuration Management - component and system wide configuration */

+/*

• • Register type flags for register value descriptor:
• • describe how the value is interpreted, and handled.
• */

+#define CS_CFG_REG_TYPE_STD 0x80 /* reg is standard reg */ +#define CS_CFG_REG_TYPE_RESOURCE 0x40 /* reg is a resource */ +#define CS_CFG_REG_TYPE_VAL_PARAM 0x08 /* reg value uses param */ +#define CS_CFG_REG_TYPE_VAL_MASK 0x04 /* reg value bit masked */ +#define CS_CFG_REG_TYPE_VAL_64BIT 0x02 /* reg value 64 bit */ +#define CS_CFG_REG_TYPE_VAL_SAVE 0x01 /* reg value save on disable */

+/*

• • flags defining what device class a feature will match to when processing a
• • system configuration - used by config data and devices.
• */

+#define CS_CFG_MATCH_CLASS_SRC_ALL 0x0001 /* match any source */ +#define CS_CFG_MATCH_CLASS_SRC_ETM4 0x0002 /* match any ETMv4 device */

+/* flags defining device instance matching - used in config match desc data. */ +#define CS_CFG_MATCH_INST_ANY 0x80000000 /* any instance of a class */

+/*

• • Limit number of presets in a configuration
• • This is related to the number of bits (4) we use to select the preset on
• • the perf command line. Preset 0 is always none selected.
• • See PMU_FORMAT_ATTR(preset, "config:0-3") in coresight-etm-perf.c
• */

+#define CS_CFG_CONFIG_PRESET_MAX 15

+/**

• • Parameter descriptor for a device feature.
• • @name: Name of parameter.
• • @value: Initial or default value.
• */

+struct cscfg_parameter_desc {

• const char *name;
• u64 value;

+};

+/**

• • Representation of register value.
• • Supports full 64 bit register value, or 32 bit value with optional mask
• • value.
• • @type: define register usage and interpretation.
• • @offset: the address offset for register in the hardware device (per device specification).
• • @hw_info: optional hardware device type specific information. (ETM / CTI specific etc)
• • @val64: 64 bit value.
• • @val32: 32 bit value.
• • @mask32: 32 bit mask when using 32 bit value to access device register.
• */

+struct cscfg_regval_desc {

• struct {

• u32 type:8;
  

• u32 offset:12;
  

• u32 hw_info:12;
  

• };
• union {

• u64 val64;
  

• struct {
  

• 	u32 val32;
  

• 	u32 mask32;
  

• };
  

• };

+};

+/**

• • Device feature descriptor - combination of registers and parameters to
• • program a device to implement a specific complex function.
• • @name: feature name.
• • @brief: brief description of the feature.
• • @item: List entry.
• • @match_flags: matching information if loading into a device
• • @nr_params: number of parameters used.
• • @params: array of parameters used.
• • @nr_regs: number of registers used.
• • @reg: array of registers used.
• */

+struct cscfg_feature_desc {

• const char *name;
• const char *brief;
• struct list_head item;
• u32 match_flags;
• int nr_params;
• struct cscfg_parameter_desc *params;
• int nr_regs;
• struct cscfg_regval_desc *regs;

+};

+/**

• • Match descriptor - Device / feature matching when loading into devices
• • Used by loading configurations to define which class or specific devices
• • they want to match used features to, and registered devices to specify which
• • matching class and information they support.
• • The load process uses these matching pairs to load feature instances into
• • matching devices.
• • @match_flags: used to match to a particular class of device.
• */

+struct cscfg_match_desc {

• u32 match_flags;

+};

+/**

• • Descriptor for features referenced by a configuration.
• • @name: name of feature to use. Match against the @name in struct

• • cscfg_feature_desc.
    

• • @match: match info for the feature when used in this configuration -

• • may be all devices of a class or a specific device in that class.
    

• */

+struct cscfg_config_feat_ref {

• const char *name;
• struct cscfg_match_desc match;

I would get rid of structure cscfg_match_desc and put @match_flags right here.

How often do you envision features having different matches for different configuration? If there is no real use for it we could use @name and @match_flags from structure cscfg_feature_desck and get rid of cscfg_config_feat_ref entirely.

+};

+/**

• • Configuration descriptor - describes selectable system configuration.
• • A configuration describes device features in use, and may provide preset
• • values for the parameters in those features.
• • A single set of presets is the sum of the parameters declared by
• • all the features in use - this value is @nr_total_params.
• • @name: name of the configuration - used for selection.
• • @brief: description of the purpose of the configuration.
• • @item: list entry.
• • @nr_refs: Number of features used in this configuration.
• • @refs: references to features used in this configuration..
• • @nr_presets: Number of sets of presets supplied by this configuration.
• • @nr_total_params: Sum of all parameters declared by used features
• • @presets: Array of preset values.
• */

+struct cscfg_config_desc {

• const char *name;
• const char *brief;
• struct list_head item;
• int nr_refs;
• struct cscfg_config_feat_ref *refs;
• int nr_presets;
• int nr_total_params;
• const u64 *presets; /* nr_presets * nr_total_params */

+};

+#endif /* _CORESIGHT_CORESIGHT_CONFIG_H */ diff --git a/drivers/hwtracing/coresight/coresight-core.c b/drivers/hwtracing/coresight/coresight-core.c index 0062c8935653..6bd41de46648 100644 --- a/drivers/hwtracing/coresight/coresight-core.c +++ b/drivers/hwtracing/coresight/coresight-core.c @@ -21,6 +21,7 @@ #include "coresight-etm-perf.h" #include "coresight-priv.h" +#include "coresight-syscfg.h" static DEFINE_MUTEX(coresight_mutex); @@ -1739,13 +1740,22 @@ static int __init coresight_init(void) ret = etm_perf_init(); if (ret)

• bus_unregister(&coresight_bustype);
  

• goto exit_bus_unregister;
  

• /* initialise the coresight syscfg API */
• ret = cscfg_init();
• if (!ret)

• return 0;
  

• etm_perf_exit();

+exit_bus_unregister:

• bus_unregister(&coresight_bustype); return ret;

} static void __exit coresight_exit(void) {

• cscfg_exit(); etm_perf_exit(); bus_unregister(&coresight_bustype);

} diff --git a/drivers/hwtracing/coresight/coresight-etm-perf.c b/drivers/hwtracing/coresight/coresight-etm-perf.c index bdc34ca449f7..a608081bd446 100644 --- a/drivers/hwtracing/coresight/coresight-etm-perf.c +++ b/drivers/hwtracing/coresight/coresight-etm-perf.c @@ -627,7 +627,7 @@ int __init etm_perf_init(void) return ret; } -void __exit etm_perf_exit(void) +void etm_perf_exit(void) { perf_pmu_unregister(&etm_pmu); }

Ok

diff --git a/drivers/hwtracing/coresight/coresight-etm-perf.h b/drivers/hwtracing/coresight/coresight-etm-perf.h index 3e4f2ad5e193..29d90dfeba31 100644 --- a/drivers/hwtracing/coresight/coresight-etm-perf.h +++ b/drivers/hwtracing/coresight/coresight-etm-perf.h @@ -83,6 +83,6 @@ static inline void *etm_perf_sink_config(struct perf_output_handle *handle) #endif /* CONFIG_CORESIGHT */ int __init etm_perf_init(void); -void __exit etm_perf_exit(void); +void etm_perf_exit(void);

Ok

#endif diff --git a/drivers/hwtracing/coresight/coresight-syscfg.c b/drivers/hwtracing/coresight/coresight-syscfg.c new file mode 100644 index 000000000000..f7e396a5f9cb --- /dev/null +++ b/drivers/hwtracing/coresight/coresight-syscfg.c @@ -0,0 +1,197 @@ +// SPDX-License-Identifier: GPL-2.0 +/*

• • Copyright (c) 2020 Linaro Limited, All rights reserved.
• • Author: Mike Leach mike.leach@linaro.org
• */

+#include <linux/platform_device.h>

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

+/*

• • cscfg_ API manages configurations and features for the entire coresight
• • infrastructure.
• • It allows the loading of configurations and features, and loads these into
• • coresight devices as appropriate.
• */

+/* protect the cscsg_data and device */ +static DEFINE_MUTEX(cscfg_mutex);

+/* only one of these */ +static struct cscfg_manager *cscfg_mgr;

+/* load features and configuations into the lists */

+/* check feature list for a named feature - call with mutex locked. */ +static bool cscfg_match_list_feat(const char *name) +{

• struct cscfg_feature_desc *curr_item;
• list_for_each_entry(curr_item, &cscfg_mgr->data.feat_desc_list, item) {

• if (strcmp(curr_item->name, name) == 0)
  

• 	return true;
  

• }
• return false;

+}

+/* check all feat needed for cfg are in the list - call with mutex locked. */ +static int cscfg_check_feat_for_cfg(struct cscfg_config_desc *cfg_desc) +{

• int i;
• for (i = 0; i < cfg_desc->nr_refs; i++)

• if (!cscfg_match_list_feat(cfg_desc->refs[i].name))
  

• 	return -EINVAL;
  

• return 0;

+}

+/*

• • load feature - add to feature list.
• */

+static int cscfg_load_feat(struct cscfg_feature_desc *feat_desc) +{

• list_add(&feat_desc->item, &cscfg_mgr->data.feat_desc_list);
• return 0;

+}

+/*

• • load config into the system - validate used features exist then add to
• • config list.
• */

+static int cscfg_load_config(struct cscfg_config_desc *cfg_desc) +{

• int err;
• /* validate features are present */
• err = cscfg_check_feat_for_cfg(cfg_desc);
• if (err)

• return err;
  

• list_add(&cfg_desc->item, &cscfg_mgr->data.config_desc_list);
• return 0;

+}

+/*

• • External API function to load feature and config sets.
• • Take a 0 terminated array of feature descriptors and/or configuration
• • descriptors and load into the system.
• • Features are loaded first to ensure configuration dependencies can be met.
• */

+int cscfg_load_config_sets(struct cscfg_config_desc **cfg_descs,

• 	   struct cscfg_feature_desc **feat_descs)
  

+{

• int err, i = 0;
• mutex_lock(&cscfg_mutex);
• /* load features first */
• if (feat_descs) {

• while (feat_descs[i]) {
  

• 	err = cscfg_load_feat(feat_descs[i]);
  

• 	if (err) {
  

• 		pr_err("coresight-syscfg: Failed to load feature %s\n",
  

• 		       feat_descs[i]->name);
  

• 		goto do_unlock;
  

• 	}
  

• 	i++;
  

• }
  

• }
• /* next any configurations to check feature dependencies */
• i = 0;
• if (cfg_descs) {

• while (cfg_descs[i]) {
  

• 	err = cscfg_load_config(cfg_descs[i]);
  

• 	if (err) {
  

• 		pr_err("coresight-syscfg: Failed to load configuration %s\n",
  

• 		       cfg_descs[i]->name);
  

• 		goto do_unlock;
  

• 	}
  

• 	i++;
  

• }
  

• }

+do_unlock:

• mutex_unlock(&cscfg_mutex);
• return err;

+} +EXPORT_SYMBOL_GPL(cscfg_load_config_sets);

+/* Initialise system configuration management device. */

+struct device *to_device_cscfg(void) +{

• return cscfg_mgr ? &cscfg_mgr->dev : NULL;

+}

+/* Must have a release function or the kernel will complain on module unload */ +void cscfg_dev_release(struct device *dev) +{

• kfree(cscfg_mgr);
• cscfg_mgr = NULL;

+}

+/* a device is needed to "own" some kernel elements such as sysfs entries. */ +int cscfg_create_device(void) +{

• struct device *dev;
• int err = -ENOMEM;
• mutex_lock(&cscfg_mutex);
• if (cscfg_mgr) {

• err = -EINVAL;
  

• goto create_dev_exit_unlock;
  

• }
• cscfg_mgr = kzalloc(sizeof(struct cscfg_manager), GFP_KERNEL);
• if (!cscfg_mgr)

• goto create_dev_exit_unlock;
  

• /* setup the device */
• dev = to_device_cscfg();
• dev->release = cscfg_dev_release;
• dev->init_name = "system_cfg";
• err = device_register(dev);
• if (err)

• cscfg_dev_release(dev);
  

+create_dev_exit_unlock:

• mutex_unlock(&cscfg_mutex);
• return err;

+}

Much cleaner

+void cscfg_clear_device(void) +{

• mutex_lock(&cscfg_mutex);
• device_unregister(to_device_cscfg());
• mutex_unlock(&cscfg_mutex);

+}

+/* Initialise system config management API device */ +int __init cscfg_init(void) +{

• int err = 0;
• err = cscfg_create_device();
• if (err)

• return err;
  

• INIT_LIST_HEAD(&cscfg_mgr->data.csdev_desc_list);
• INIT_LIST_HEAD(&cscfg_mgr->data.feat_desc_list);
• INIT_LIST_HEAD(&cscfg_mgr->data.config_desc_list);
• cscfg_mgr->data.nr_csdev = 0;

We are keeping track of the number of cs devices registered with the manager but I don't see a place (in this patchset) where the information is used. If indeed we dont' need it I suggest moving the lists held in cscfg_api_data directly to cscfg_manager.

• dev_info(to_device_cscfg(), "CoreSight Configuration manager initialised");
• return 0;

+}

+void __exit cscfg_exit(void) +{

• cscfg_clear_device();

+} diff --git a/drivers/hwtracing/coresight/coresight-syscfg.h b/drivers/hwtracing/coresight/coresight-syscfg.h new file mode 100644 index 000000000000..907ba8d3efea --- /dev/null +++ b/drivers/hwtracing/coresight/coresight-syscfg.h @@ -0,0 +1,54 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/*

• • Coresight system configuration driver.
• */

+#ifndef CORESIGHT_SYSCFG_H +#define CORESIGHT_SYSCFG_H

+#include <linux/coresight.h> +#include <linux/device.h>

+#include "coresight-config.h"

+/**

• • System configuration manager API data.
• • @csdev_list: List of coresight devices registered with the configuration manager.
• • @feat_desc_list: List of feature descriptors to load into registered devices.
• • @config_desc_list: List of system configuration descriptors to load into registered devices.
• • @nr_csdev: Number of registered devices with the cscfg system
• */

+struct cscfg_api_data {

• struct list_head csdev_desc_list;
• struct list_head feat_desc_list;
• struct list_head config_desc_list;
• int nr_csdev;

+};

+/* internal core operations for cscfg */ +int __init cscfg_init(void); +void __exit cscfg_exit(void);

+/* syscfg manager external API */ +int cscfg_load_config_sets(struct cscfg_config_desc **cfg_descs,

• 	   struct cscfg_feature_desc **feat_descs);
  

+/**

• • System configuration manager device.
• • Need a device to 'own' some coresight system wide sysfs entries in
• • perf events, configfs etc.
• • @dev: The device.
• • @data: The API data.
• */

+struct cscfg_manager {

• struct device dev;
• struct cscfg_api_data data;

+};

+/* get reference to dev in cscfg_manager */ +struct device *to_device_cscfg(void);

This patch looks really good now. More comments to come tomorrow.

Thanks, Mathieu

+#endif /* CORESIGHT_SYSCFG_H */

2.17.1

Hi Mike,

On Thu, Jan 28, 2021 at 05:09:28PM +0000, Mike Leach wrote:

API for individual devices to register with the syscfg management system is added.

Devices register with matching information, and any features or configurations that match will be loaded into the device.

The feature and configuration loading is extended so that on load these are loaded into any currently registered devices. This allows configuration loading after devices have been registered.

Signed-off-by: Mike Leach mike.leach@linaro.org

.../hwtracing/coresight/coresight-config.h | 98 +++++ .../hwtracing/coresight/coresight-syscfg.c | 348 ++++++++++++++++++ .../hwtracing/coresight/coresight-syscfg.h | 20 + include/linux/coresight.h | 5 + 4 files changed, 471 insertions(+)

diff --git a/drivers/hwtracing/coresight/coresight-config.h b/drivers/hwtracing/coresight/coresight-config.h index 3fedf8ab3cee..75ecdecf7013 100644 --- a/drivers/hwtracing/coresight/coresight-config.h +++ b/drivers/hwtracing/coresight/coresight-config.h @@ -164,4 +164,102 @@ struct cscfg_config_desc { const u64 *presets; /* nr_presets * nr_total_params */ }; +/**

• • config register instance - part of a loaded feature.

• •                        maps register values to csdev driver structures
    

• • @value: value to use when setting feature on device / store for

• • readback of volatile values.
    

• • @drv_store: pointer to internal driver element used to set the value

• • in hardware.
    

• */

+struct cscfg_reg_csdev {

Please rename this cscfg_regval_csdev to highlight the 1:1 mapping with cscfg_regval_desc. Or rename cscfg_regval_desc to cscfg_reg_desc. I have no opinion on which one it should be, as long as they are consistent. Doing so really helps getting over the naming convention so that we can focus on the core of the feature.

• struct cscfg_regval_desc value;
• void *drv_store;

+};

+/**

• • config parameter instance - part of a loaded feature.
• • @feat: parent feature
• • @reg: register value updated by this parameter.
• • @current_value: current value of parameter - may be set by user via

• • 	sysfs, or modified during device operation.
    

• • @val64: true if 64 bit value
• */

+struct cscfg_parameter_csdev {

• struct cscfg_feature_csdev *feat;
• struct cscfg_reg_csdev *reg;
• u64 current_value;
• bool val64;

+};

+/**

• • Feature instance loaded into a CoreSight device.
• • When a feature is loaded into a specific device, then this structure holds
• • the connections between the register / parameter values used and the
• • internal data structures that are written when the feature is enabled.
• • Since applying a feature modifies internal data structures in the device,
• • then we have a reference to the device spinlock to protect access to these
• • structures (@csdev_spinlock).
• • @desc: pointer to the static descriptor for this feature.
• • @csdev: parent CoreSight device instance.
• • @node: list entry into feature list for this device.
• • @csdev_spinlock: device spinlock from csdev instance..
• • @nr_params: number of parameters.
• • @params: current parameter values on this device
• • @nr_regs: number of registers to be programmed.
• • @regs: Programming details for the registers
• */

+struct cscfg_feature_csdev {

• const struct cscfg_feature_desc *desc;
• struct coresight_device *csdev;
• struct list_head node;
• spinlock_t *csdev_spinlock;
• int nr_params;
• struct cscfg_parameter_csdev *params;
• int nr_regs;
• struct cscfg_reg_csdev *regs;

+};

+/**

• • Configuration instance when loaded into a CoreSight device.
• • The instance contains references to loaded features on this device that are
• • used by the configuration.
• • @desc: reference to the descriptor for this configuration
• • @csdev: parent coresight device for this configuration instance.
• • @node: list entry within the coresight device
• • @nr_feat: Number of features on this device that are used in the

• •  configuration.
    

• • @feats: reference to the device features to enable.
• • @enabled: true if configuration is enabled on this device.
• */

+struct cscfg_config_csdev {

• const struct cscfg_config_desc *desc;
• struct coresight_device *csdev;
• struct list_head node;
• int nr_feat;
• struct cscfg_feature_csdev **feats;
• bool enabled;

+};

+/**

• • Coresight device operations.
• • Registered coresight devices provide these operations to manage feature
• • instances compatible with the device hardware and drivers
• • @load_feat: Pass a feature descriptor into the device and create the

• • loaded feature instance (struct cscfg_feature_csdev).
    

• */

+struct cscfg_csdev_feat_ops {

• int (*load_feat)(struct coresight_device *csdev,

• 	 struct cscfg_feature_csdev *feat);
  

+};

#endif /* _CORESIGHT_CORESIGHT_CONFIG_H */ diff --git a/drivers/hwtracing/coresight/coresight-syscfg.c b/drivers/hwtracing/coresight/coresight-syscfg.c index f7e396a5f9cb..c04cea0c1db2 100644 --- a/drivers/hwtracing/coresight/coresight-syscfg.c +++ b/drivers/hwtracing/coresight/coresight-syscfg.c @@ -25,6 +25,212 @@ static struct cscfg_manager *cscfg_mgr; /* load features and configuations into the lists */ +/* protect the cfg lists in the csdev instances */ +static DEFINE_MUTEX(cscfg_csdev_mutex);

+/* get name feature instance from a coresight device list of features */ +static struct cscfg_feature_csdev * +cscfg_get_feat_csdev(struct coresight_device *csdev, const char *name) +{

• struct cscfg_feature_csdev *feat = NULL;
• list_for_each_entry(feat, &csdev->feature_csdev_list, node) {

• if (strcmp(feat->desc->name, name) == 0)
  

• 	return feat;
  

• }
• return NULL;

+}

+/* allocate the device config instance - with max number of used features */ +static struct cscfg_config_csdev * +cscfg_alloc_csdev_cfg(struct coresight_device *csdev, int nr_feats) +{

• struct cscfg_config_csdev *dev_cfg = NULL;
• struct device *dev = csdev->dev.parent;
• /* this is being allocated using the devm for the coresight device */
• dev_cfg = devm_kzalloc(dev, sizeof(struct cscfg_config_csdev), GFP_KERNEL);
• if (!dev_cfg)

• return NULL;
  

• dev_cfg->csdev = csdev;
• dev_cfg->feats = devm_kcalloc(dev, nr_feats,

• 		      sizeof(struct cscfg_feature_csdev *),
  

• 		      GFP_KERNEL);
  

• if (!dev_cfg->feats)

• dev_cfg = NULL;
  

• return dev_cfg;

+}

+/* check match info between used feature from the config and a regisered device */ +static bool cscfg_match_feat_info(struct cscfg_match_desc *used_cmp,

• 		  struct cscfg_match_desc *reg_dev)
  

+{

• /* if flags don't match then fail early */
• if (!(used_cmp->match_flags & reg_dev->match_flags))

• return false;
  

• return true;

+}

+/* Load a config into a device if there are feature matches between config and device */ +static int cscfg_add_csdev_cfg(struct coresight_device *csdev,

• 	       struct cscfg_match_desc *match_info,
  

• 	       struct cscfg_config_desc *cfg_desc)
  

struct cscfg_config_desc *config_desc)

+{

• struct cscfg_config_csdev *dev_cfg = NULL;

struct cscfg_config_csdev *config_csdev = NULL;

• struct cscfg_config_feat_ref *feat_ref;
• struct cscfg_feature_csdev *feat;

struct cscfg_feature_csdev *feat_csdev;

Please appy this kind of naming convention throughout the patchset.

• int checked;
• /* look at each required feature and see if it matches any feature on the device */
• for (checked = 0; checked < cfg_desc->nr_refs; checked++) {

• feat_ref = &cfg_desc->refs[checked];
  

• if (cscfg_match_feat_info(&feat_ref->match, match_info)) {
  

• 	/* device matched - get the feature */
  

• 	feat = cscfg_get_feat_csdev(csdev, feat_ref->name);
  

• 	if (!feat)
  

• 		return -EINVAL;
  

• 	if (!dev_cfg) {
  

• 		dev_cfg = cscfg_alloc_csdev_cfg(csdev, cfg_desc->nr_refs);
  

• 		if (!dev_cfg)
  

• 			return -ENOMEM;
  

• 		dev_cfg->desc = cfg_desc;
  

• 	}
  

• 	dev_cfg->feats[dev_cfg->nr_feat++] = feat;
  

• }
  

• }
• /* if matched features, add config to device.*/
• if (dev_cfg) {

• mutex_lock(&cscfg_csdev_mutex);
  

• list_add(&dev_cfg->node, &csdev->config_csdev_list);
  

• mutex_unlock(&cscfg_csdev_mutex);
  

• }
• return 0;

+}

+/*

• • Add the config to the set of registered devices - call with mutex locked.
• • Iterates through devices - any device that matches one or more of the
• • configuration features will load it, the others will ignore it.
• */

+static int cscfg_add_cfg_to_csdevs(struct cscfg_config_desc *cfg_desc) +{

• struct cscfg_csdev_register *curr_item;
• int err;
• list_for_each_entry(curr_item, &cscfg_mgr->data.csdev_desc_list, item) {

• err = cscfg_add_csdev_cfg(curr_item->csdev, &curr_item->match_info, cfg_desc);
  

• if (err)
  

• 	return err;
  

• }
• return 0;

+}

+/*

• • Allocate a feature object for load into a csdev.
• • memory allocated using the csdev->dev object using devm managed allocator.
• */

+static struct cscfg_feature_csdev * +cscfg_alloc_csdev_feat(struct coresight_device *csdev, struct cscfg_feature_desc *feat_desc) +{

• struct cscfg_feature_csdev *feat = NULL;

struct cscfg_feature_csdev *feat_csdev = NULL;

• struct device *dev = csdev->dev.parent;
• int i;
• feat = devm_kzalloc(dev, sizeof(struct cscfg_feature_csdev), GFP_KERNEL);
• if (!feat)

• return NULL;
  

• /* parameters are optional - could be 0 */
• feat->nr_params = feat_desc->nr_params;
• /*

• * if we need parameters, zero alloc the space here, the load routine in
  

• * the csdev device driver will fill out some information according to
  

• * feature descriptor.
  

• */
  

• if (feat->nr_params) {

• feat->params = devm_kcalloc(dev, feat->nr_params,
  

• 			    sizeof(struct cscfg_parameter_csdev),
  

• 			    GFP_KERNEL);
  

• if (!feat->params)
  

• 	return NULL;
  

• /*
  

•  * fill in the feature reference in the param - other fields
  

•  * handled by loader in csdev.
  

•  */
  

• for (i = 0; i < feat->nr_params; i++)
  

• 	feat->params[i].feat = feat;
  

• }
• /*

• * Always have registers to program - again the load routine in csdev device
  

• * will fill out according to feature descriptor and device requirements.
  

• */
  

• feat->nr_regs = feat_desc->nr_regs;
• feat->regs = devm_kcalloc(dev, feat->nr_regs,

• 		  sizeof(struct cscfg_reg_csdev), GFP_KERNEL);
  

• if (!feat->regs)

• return NULL;
  

• /* load the feature default values */
• feat->desc = feat_desc;
• feat->csdev = csdev;
• return feat;

+}

+/* load one feature into one coresight device */ +static int cscfg_load_feat_csdev(struct coresight_device *csdev,

• 		 struct cscfg_feature_desc *feat_desc,
  

• 		 struct cscfg_csdev_feat_ops *ops)
  

+{

• struct cscfg_feature_csdev *feat_csdev;
• int err;
• if (!ops->load_feat)

• return -EINVAL;
  

• feat_csdev = cscfg_alloc_csdev_feat(csdev, feat_desc);
• if (!feat_csdev)

• return -ENOMEM;
  

• /* load the feature into the device - may modify default ops*/
• err = ops->load_feat(csdev, feat_csdev);
• if (err)

• return err;
  

• /* add to internal csdev feature list */
• mutex_lock(&cscfg_csdev_mutex);
• list_add(&feat_csdev->node, &csdev->feature_csdev_list);
• mutex_unlock(&cscfg_csdev_mutex);
• return 0;

+}

+/*

• • Add feature to any matching devices - call with mutex locked.
• • Iterates through devices - any device that matches the feature will be
• • called to load it.
• */

+static int cscfg_add_feat_to_csdevs(struct cscfg_feature_desc *feat_desc) +{

• struct cscfg_csdev_register *curr_item;
• int err;
• list_for_each_entry(curr_item, &cscfg_mgr->data.csdev_desc_list, item) {

• if (curr_item->match_info.match_flags & feat_desc->match_flags) {
  

• 	err = cscfg_load_feat_csdev(curr_item->csdev, feat_desc, &curr_item->ops);
  

• 	if (err)
  

• 		return err;
  

• }
  

• }
• return 0;

+}

/* check feature list for a named feature - call with mutex locked. */ static bool cscfg_match_list_feat(const char *name) { @@ -53,6 +259,13 @@ static int cscfg_check_feat_for_cfg(struct cscfg_config_desc *cfg_desc) */ static int cscfg_load_feat(struct cscfg_feature_desc *feat_desc) {

• int err;
• /* add feature to any matching registered devices */
• err = cscfg_add_feat_to_csdevs(feat_desc);
• if (err)

• return err;
  

• list_add(&feat_desc->item, &cscfg_mgr->data.feat_desc_list);

return 0; @@ -71,6 +284,11 @@ static int cscfg_load_config(struct cscfg_config_desc *cfg_desc) if (err) return err;

• /* add config to any matching registered device */
• err = cscfg_add_cfg_to_csdevs(cfg_desc);
• if (err)

• return err;
  

• list_add(&cfg_desc->item, &cscfg_mgr->data.config_desc_list);

return 0; @@ -122,6 +340,136 @@ int cscfg_load_config_sets(struct cscfg_config_desc **cfg_descs, } EXPORT_SYMBOL_GPL(cscfg_load_config_sets); +/* Handle coresight device registration and add configs and features to devices */

+/* iterate through config lists and load matching configs to device */ +static int cscfg_add_cfgs_csdev(struct coresight_device *csdev,

• 		struct cscfg_match_desc *info)
  

+{

• struct cscfg_config_desc *curr_item;
• int err = 0;
• list_for_each_entry(curr_item, &cscfg_mgr->data.config_desc_list, item) {

• err = cscfg_add_csdev_cfg(csdev, info, curr_item);
  

• if (err)
  

• 	break;
  

• }
• return err;

+}

+/* iterate through feature lists and load matching features to device */ +static int cscfg_add_feats_csdev(struct coresight_device *csdev,

• 		 struct cscfg_match_desc *info,
  

• 		 struct cscfg_csdev_feat_ops *ops)
  

+{

• struct cscfg_feature_desc *curr_item;
• int err = 0;
• if (!ops->load_feat)

• return -EINVAL;
  

• list_for_each_entry(curr_item, &cscfg_mgr->data.feat_desc_list, item) {

• if (curr_item->match_flags & info->match_flags) {
  

• 	err = cscfg_load_feat_csdev(csdev, curr_item, ops);
  

• 	if (err)
  

• 		break;
  

• }
  

• }
• return err;

+}

+/* Add coresight device to list and copy its matching info */ +static int cscfg_list_add_csdev(struct coresight_device *csdev,

• 		struct cscfg_match_desc *info,
  

• 		struct cscfg_csdev_feat_ops *ops)
  

+{

• struct cscfg_csdev_register *list_entry;
• /* allocate the list entry structure */
• list_entry = kzalloc(sizeof(struct cscfg_csdev_register), GFP_KERNEL);
• if (!list_entry)

• return -ENOMEM;
  

• list_entry->csdev = csdev;
• list_entry->match_info.match_flags = info->match_flags;
• list_entry->ops.load_feat = ops->load_feat;
• list_add(&list_entry->item, &cscfg_mgr->data.csdev_desc_list);
• INIT_LIST_HEAD(&csdev->feature_csdev_list);
• INIT_LIST_HEAD(&csdev->config_csdev_list);
• cscfg_mgr->data.nr_csdev++;
• return 0;

+}

+/* remove a coresight device from the list and free data */ +static void cscfg_list_remove_csdev(struct coresight_device *csdev) +{

• struct cscfg_csdev_register *curr_item, *tmp;
• list_for_each_entry_safe(curr_item, tmp, &cscfg_mgr->data.csdev_desc_list, item) {

• if (curr_item->csdev == csdev) {
  

• 	list_del(&curr_item->item);
  

• 	kfree(curr_item);
  

• 	cscfg_mgr->data.nr_csdev--;
  

• 	break;
  

• }
  

• }

+}

+/* register a coresight device with the syscfg api */ +int cscfg_register_csdev(struct coresight_device *csdev,

• 	 struct cscfg_match_desc *info,
  

• 	 struct cscfg_csdev_feat_ops *ops)
  

+{

• int ret = 0;
• mutex_lock(&cscfg_mutex);
• /* add device to list of registered devices */
• ret = cscfg_list_add_csdev(csdev, info, ops);
• if (ret)

• goto reg_csdev_unlock;
  

• /* now load any registered features and configs matching the device. */
• ret = cscfg_add_feats_csdev(csdev, info, ops);
• if (ret) {

• cscfg_list_remove_csdev(csdev);
  

• goto reg_csdev_unlock;
  

• }
• ret = cscfg_add_cfgs_csdev(csdev, info);
• if (ret) {

• cscfg_list_remove_csdev(csdev);
  

• goto reg_csdev_unlock;
  

• }
• pr_info("CSCFG registered %s", dev_name(&csdev->dev));

+reg_csdev_unlock:

• mutex_unlock(&cscfg_mutex);
• return ret;

+} +EXPORT_SYMBOL_GPL(cscfg_register_csdev);

+/* remove coresight device and update counts - syscfg device at 0 */ +void cscfg_unregister_csdev(struct coresight_device *csdev) +{

• struct cscfg_csdev_register *curr_item, *tmp;
• mutex_lock(&cscfg_mutex);
• list_for_each_entry_safe(curr_item, tmp, &cscfg_mgr->data.csdev_desc_list, item) {

• if (curr_item->csdev == csdev) {
  

• 	list_del(&curr_item->item);
  

• 	kfree(curr_item);
  

• 	cscfg_mgr->data.nr_csdev--;
  

• 	break;
  

• }
  

• }
• mutex_unlock(&cscfg_mutex);

+} +EXPORT_SYMBOL_GPL(cscfg_unregister_csdev);

/* Initialise system configuration management device. */ struct device *to_device_cscfg(void) diff --git a/drivers/hwtracing/coresight/coresight-syscfg.h b/drivers/hwtracing/coresight/coresight-syscfg.h index 907ba8d3efea..ebf5e1491d86 100644 --- a/drivers/hwtracing/coresight/coresight-syscfg.h +++ b/drivers/hwtracing/coresight/coresight-syscfg.h @@ -26,6 +26,22 @@ struct cscfg_api_data { int nr_csdev; }; +/**

• • List entry for Coresight devices that are registered as supporting complex
• • config operations.
• • @csdev: The registered device.
• • @match_info: The matching type information.
• • @ops: Operations supported by the registered device.
• • @item: list entry.
• */

+struct cscfg_csdev_register {

• struct coresight_device *csdev;
• struct cscfg_match_desc match_info;
• struct cscfg_csdev_feat_ops ops;
• struct list_head item;

+};

/* internal core operations for cscfg */ int __init cscfg_init(void); void __exit cscfg_exit(void); @@ -33,6 +49,10 @@ void __exit cscfg_exit(void); /* syscfg manager external API */ int cscfg_load_config_sets(struct cscfg_config_desc **cfg_descs, struct cscfg_feature_desc **feat_descs); +int cscfg_register_csdev(struct coresight_device *csdev,

• 	 struct cscfg_match_desc *info,
  

• 	 struct cscfg_csdev_feat_ops *ops);
  

+void cscfg_unregister_csdev(struct coresight_device *csdev); /**

• System configuration manager device.

diff --git a/include/linux/coresight.h b/include/linux/coresight.h index 976ec2697610..d0126ed326a6 100644 --- a/include/linux/coresight.h +++ b/include/linux/coresight.h @@ -219,6 +219,8 @@ struct coresight_sysfs_link {

• @nr_links: number of sysfs links created to other components from this

• device. These will appear in the "connections" group.
  

• @has_conns_grp: Have added a "connections" group for sysfs links.

• • @feature_csdev_list: List of complex feature programming added to the device.
• • @config_csdev_list: List of system configurations added to the device.
  */

struct coresight_device { struct coresight_platform_data *pdata; @@ -240,6 +242,9 @@ struct coresight_device { int nr_links; bool has_conns_grp; bool ect_enabled; /* true only if associated ect device is enabled */

• /* system configuration and feature lists */
• struct list_head feature_csdev_list;
• struct list_head config_csdev_list;

}; /* -- 2.17.1

On Thu, Jan 28, 2021 at 05:09:28PM +0000, Mike Leach wrote:

API for individual devices to register with the syscfg management system is added.

Devices register with matching information, and any features or configurations that match will be loaded into the device.

The feature and configuration loading is extended so that on load these are loaded into any currently registered devices. This allows configuration loading after devices have been registered.

Signed-off-by: Mike Leach mike.leach@linaro.org

.../hwtracing/coresight/coresight-config.h | 98 +++++ .../hwtracing/coresight/coresight-syscfg.c | 348 ++++++++++++++++++ .../hwtracing/coresight/coresight-syscfg.h | 20 + include/linux/coresight.h | 5 + 4 files changed, 471 insertions(+)

diff --git a/drivers/hwtracing/coresight/coresight-config.h b/drivers/hwtracing/coresight/coresight-config.h index 3fedf8ab3cee..75ecdecf7013 100644 --- a/drivers/hwtracing/coresight/coresight-config.h +++ b/drivers/hwtracing/coresight/coresight-config.h @@ -164,4 +164,102 @@ struct cscfg_config_desc { const u64 *presets; /* nr_presets * nr_total_params */ }; +/**

• • config register instance - part of a loaded feature.

• •                        maps register values to csdev driver structures
    

• • @value: value to use when setting feature on device / store for

• • readback of volatile values.
    

• • @drv_store: pointer to internal driver element used to set the value

• • in hardware.
    

• */

+struct cscfg_reg_csdev {

• struct cscfg_regval_desc value;

struct cscfg_regval_desc reg_desc;

• void *drv_store;

+};

+/**

• • config parameter instance - part of a loaded feature.
• • @feat: parent feature
• • @reg: register value updated by this parameter.
• • @current_value: current value of parameter - may be set by user via

• • 	sysfs, or modified during device operation.
    

• • @val64: true if 64 bit value
• */

+struct cscfg_parameter_csdev {

• struct cscfg_feature_csdev *feat;

struct cscfg_feature_csdev *feat_csdev;

• struct cscfg_reg_csdev *reg;

struct cscfg_reg_csdev *reg_csdev;

• u64 current_value;
• bool val64;

+};

+/**

• • Feature instance loaded into a CoreSight device.
• • When a feature is loaded into a specific device, then this structure holds
• • the connections between the register / parameter values used and the
• • internal data structures that are written when the feature is enabled.
• • Since applying a feature modifies internal data structures in the device,
• • then we have a reference to the device spinlock to protect access to these
• • structures (@csdev_spinlock).
• • @desc: pointer to the static descriptor for this feature.
• • @csdev: parent CoreSight device instance.
• • @node: list entry into feature list for this device.
• • @csdev_spinlock: device spinlock from csdev instance..
• • @nr_params: number of parameters.
• • @params: current parameter values on this device
• • @nr_regs: number of registers to be programmed.
• • @regs: Programming details for the registers
• */

+struct cscfg_feature_csdev {

• const struct cscfg_feature_desc *desc;

const struct cscfg_feature_desc *feat_desc;

• struct coresight_device *csdev;
• struct list_head node;
• spinlock_t *csdev_spinlock;
• int nr_params;
• struct cscfg_parameter_csdev *params;

struct cscfg_parameter_csdev *params_csdev;

• int nr_regs;
• struct cscfg_reg_csdev *regs;

struct cscfg_reg_csdev *regs_csdev;

+};

+/**

• • Configuration instance when loaded into a CoreSight device.
• • The instance contains references to loaded features on this device that are
• • used by the configuration.
• • @desc: reference to the descriptor for this configuration
• • @csdev: parent coresight device for this configuration instance.
• • @node: list entry within the coresight device
• • @nr_feat: Number of features on this device that are used in the

• •  configuration.
    

• • @feats: reference to the device features to enable.
• • @enabled: true if configuration is enabled on this device.
• */

+struct cscfg_config_csdev {

• const struct cscfg_config_desc *desc;

const struct cscfg_config_desc *cfg_desc;

• struct coresight_device *csdev;
• struct list_head node;
• int nr_feat;
• struct cscfg_feature_csdev **feats;

struct cscfg_feature_csdev **feat_csdev;

• bool enabled;

+};

+/**

• • Coresight device operations.
• • Registered coresight devices provide these operations to manage feature
• • instances compatible with the device hardware and drivers
• • @load_feat: Pass a feature descriptor into the device and create the

• • loaded feature instance (struct cscfg_feature_csdev).
    

• */

+struct cscfg_csdev_feat_ops {

• int (*load_feat)(struct coresight_device *csdev,

• 	 struct cscfg_feature_csdev *feat);
  

struct cscfg_feature_csdev *feat_csdev);

Please pick the same convention for naming structure throughout the entire patchset for declaration and function parameters. I know it is a lot of modifications but it is the only way I can concentrate on the feature being added without having to constantly go back to the header files.

Thanks, Mathieu

+};

#endif /* _CORESIGHT_CORESIGHT_CONFIG_H */ diff --git a/drivers/hwtracing/coresight/coresight-syscfg.c b/drivers/hwtracing/coresight/coresight-syscfg.c index f7e396a5f9cb..c04cea0c1db2 100644 --- a/drivers/hwtracing/coresight/coresight-syscfg.c +++ b/drivers/hwtracing/coresight/coresight-syscfg.c @@ -25,6 +25,212 @@ static struct cscfg_manager *cscfg_mgr; /* load features and configuations into the lists */ +/* protect the cfg lists in the csdev instances */ +static DEFINE_MUTEX(cscfg_csdev_mutex);

+/* get name feature instance from a coresight device list of features */ +static struct cscfg_feature_csdev * +cscfg_get_feat_csdev(struct coresight_device *csdev, const char *name) +{

• struct cscfg_feature_csdev *feat = NULL;
• list_for_each_entry(feat, &csdev->feature_csdev_list, node) {

• if (strcmp(feat->desc->name, name) == 0)
  

• 	return feat;
  

• }
• return NULL;

+}

+/* allocate the device config instance - with max number of used features */ +static struct cscfg_config_csdev * +cscfg_alloc_csdev_cfg(struct coresight_device *csdev, int nr_feats) +{

• struct cscfg_config_csdev *dev_cfg = NULL;
• struct device *dev = csdev->dev.parent;
• /* this is being allocated using the devm for the coresight device */
• dev_cfg = devm_kzalloc(dev, sizeof(struct cscfg_config_csdev), GFP_KERNEL);
• if (!dev_cfg)

• return NULL;
  

• dev_cfg->csdev = csdev;
• dev_cfg->feats = devm_kcalloc(dev, nr_feats,

• 		      sizeof(struct cscfg_feature_csdev *),
  

• 		      GFP_KERNEL);
  

• if (!dev_cfg->feats)

• dev_cfg = NULL;
  

• return dev_cfg;

+}

+/* check match info between used feature from the config and a regisered device */ +static bool cscfg_match_feat_info(struct cscfg_match_desc *used_cmp,

• 		  struct cscfg_match_desc *reg_dev)
  

+{

• /* if flags don't match then fail early */
• if (!(used_cmp->match_flags & reg_dev->match_flags))

• return false;
  

• return true;

+}

+/* Load a config into a device if there are feature matches between config and device */ +static int cscfg_add_csdev_cfg(struct coresight_device *csdev,

• 	       struct cscfg_match_desc *match_info,
  

• 	       struct cscfg_config_desc *cfg_desc)
  

+{

• struct cscfg_config_csdev *dev_cfg = NULL;
• struct cscfg_config_feat_ref *feat_ref;
• struct cscfg_feature_csdev *feat;
• int checked;
• /* look at each required feature and see if it matches any feature on the device */
• for (checked = 0; checked < cfg_desc->nr_refs; checked++) {

• feat_ref = &cfg_desc->refs[checked];
  

• if (cscfg_match_feat_info(&feat_ref->match, match_info)) {
  

• 	/* device matched - get the feature */
  

• 	feat = cscfg_get_feat_csdev(csdev, feat_ref->name);
  

• 	if (!feat)
  

• 		return -EINVAL;
  

• 	if (!dev_cfg) {
  

• 		dev_cfg = cscfg_alloc_csdev_cfg(csdev, cfg_desc->nr_refs);
  

• 		if (!dev_cfg)
  

• 			return -ENOMEM;
  

• 		dev_cfg->desc = cfg_desc;
  

• 	}
  

• 	dev_cfg->feats[dev_cfg->nr_feat++] = feat;
  

• }
  

• }
• /* if matched features, add config to device.*/
• if (dev_cfg) {

• mutex_lock(&cscfg_csdev_mutex);
  

• list_add(&dev_cfg->node, &csdev->config_csdev_list);
  

• mutex_unlock(&cscfg_csdev_mutex);
  

• }
• return 0;

+}

+/*

• • Add the config to the set of registered devices - call with mutex locked.
• • Iterates through devices - any device that matches one or more of the
• • configuration features will load it, the others will ignore it.
• */

+static int cscfg_add_cfg_to_csdevs(struct cscfg_config_desc *cfg_desc) +{

• struct cscfg_csdev_register *curr_item;
• int err;
• list_for_each_entry(curr_item, &cscfg_mgr->data.csdev_desc_list, item) {

• err = cscfg_add_csdev_cfg(curr_item->csdev, &curr_item->match_info, cfg_desc);
  

• if (err)
  

• 	return err;
  

• }
• return 0;

+}

+/*

• • Allocate a feature object for load into a csdev.
• • memory allocated using the csdev->dev object using devm managed allocator.
• */

+static struct cscfg_feature_csdev * +cscfg_alloc_csdev_feat(struct coresight_device *csdev, struct cscfg_feature_desc *feat_desc) +{

• struct cscfg_feature_csdev *feat = NULL;
• struct device *dev = csdev->dev.parent;
• int i;
• feat = devm_kzalloc(dev, sizeof(struct cscfg_feature_csdev), GFP_KERNEL);
• if (!feat)

• return NULL;
  

• /* parameters are optional - could be 0 */
• feat->nr_params = feat_desc->nr_params;
• /*

• * if we need parameters, zero alloc the space here, the load routine in
  

• * the csdev device driver will fill out some information according to
  

• * feature descriptor.
  

• */
  

• if (feat->nr_params) {

• feat->params = devm_kcalloc(dev, feat->nr_params,
  

• 			    sizeof(struct cscfg_parameter_csdev),
  

• 			    GFP_KERNEL);
  

• if (!feat->params)
  

• 	return NULL;
  

• /*
  

•  * fill in the feature reference in the param - other fields
  

•  * handled by loader in csdev.
  

•  */
  

• for (i = 0; i < feat->nr_params; i++)
  

• 	feat->params[i].feat = feat;
  

• }
• /*

• * Always have registers to program - again the load routine in csdev device
  

• * will fill out according to feature descriptor and device requirements.
  

• */
  

• feat->nr_regs = feat_desc->nr_regs;
• feat->regs = devm_kcalloc(dev, feat->nr_regs,

• 		  sizeof(struct cscfg_reg_csdev), GFP_KERNEL);
  

• if (!feat->regs)

• return NULL;
  

• /* load the feature default values */
• feat->desc = feat_desc;
• feat->csdev = csdev;
• return feat;

+}

+/* load one feature into one coresight device */ +static int cscfg_load_feat_csdev(struct coresight_device *csdev,

• 		 struct cscfg_feature_desc *feat_desc,
  

• 		 struct cscfg_csdev_feat_ops *ops)
  

+{

• struct cscfg_feature_csdev *feat_csdev;
• int err;
• if (!ops->load_feat)

• return -EINVAL;
  

• feat_csdev = cscfg_alloc_csdev_feat(csdev, feat_desc);
• if (!feat_csdev)

• return -ENOMEM;
  

• /* load the feature into the device - may modify default ops*/
• err = ops->load_feat(csdev, feat_csdev);
• if (err)

• return err;
  

• /* add to internal csdev feature list */
• mutex_lock(&cscfg_csdev_mutex);
• list_add(&feat_csdev->node, &csdev->feature_csdev_list);
• mutex_unlock(&cscfg_csdev_mutex);
• return 0;

+}

+/*

• • Add feature to any matching devices - call with mutex locked.
• • Iterates through devices - any device that matches the feature will be
• • called to load it.
• */

+static int cscfg_add_feat_to_csdevs(struct cscfg_feature_desc *feat_desc) +{

• struct cscfg_csdev_register *curr_item;
• int err;
• list_for_each_entry(curr_item, &cscfg_mgr->data.csdev_desc_list, item) {

• if (curr_item->match_info.match_flags & feat_desc->match_flags) {
  

• 	err = cscfg_load_feat_csdev(curr_item->csdev, feat_desc, &curr_item->ops);
  

• 	if (err)
  

• 		return err;
  

• }
  

• }
• return 0;

+}

/* check feature list for a named feature - call with mutex locked. */ static bool cscfg_match_list_feat(const char *name) { @@ -53,6 +259,13 @@ static int cscfg_check_feat_for_cfg(struct cscfg_config_desc *cfg_desc) */ static int cscfg_load_feat(struct cscfg_feature_desc *feat_desc) {

• int err;
• /* add feature to any matching registered devices */
• err = cscfg_add_feat_to_csdevs(feat_desc);
• if (err)

• return err;
  

• list_add(&feat_desc->item, &cscfg_mgr->data.feat_desc_list);

return 0; @@ -71,6 +284,11 @@ static int cscfg_load_config(struct cscfg_config_desc *cfg_desc) if (err) return err;

• /* add config to any matching registered device */
• err = cscfg_add_cfg_to_csdevs(cfg_desc);
• if (err)

• return err;
  

• list_add(&cfg_desc->item, &cscfg_mgr->data.config_desc_list);

return 0; @@ -122,6 +340,136 @@ int cscfg_load_config_sets(struct cscfg_config_desc **cfg_descs, } EXPORT_SYMBOL_GPL(cscfg_load_config_sets); +/* Handle coresight device registration and add configs and features to devices */

+/* iterate through config lists and load matching configs to device */ +static int cscfg_add_cfgs_csdev(struct coresight_device *csdev,

• 		struct cscfg_match_desc *info)
  

+{

• struct cscfg_config_desc *curr_item;
• int err = 0;
• list_for_each_entry(curr_item, &cscfg_mgr->data.config_desc_list, item) {

• err = cscfg_add_csdev_cfg(csdev, info, curr_item);
  

• if (err)
  

• 	break;
  

• }
• return err;

+}

+/* iterate through feature lists and load matching features to device */ +static int cscfg_add_feats_csdev(struct coresight_device *csdev,

• 		 struct cscfg_match_desc *info,
  

• 		 struct cscfg_csdev_feat_ops *ops)
  

+{

• struct cscfg_feature_desc *curr_item;
• int err = 0;
• if (!ops->load_feat)

• return -EINVAL;
  

• list_for_each_entry(curr_item, &cscfg_mgr->data.feat_desc_list, item) {

• if (curr_item->match_flags & info->match_flags) {
  

• 	err = cscfg_load_feat_csdev(csdev, curr_item, ops);
  

• 	if (err)
  

• 		break;
  

• }
  

• }
• return err;

+}

+/* Add coresight device to list and copy its matching info */ +static int cscfg_list_add_csdev(struct coresight_device *csdev,

• 		struct cscfg_match_desc *info,
  

• 		struct cscfg_csdev_feat_ops *ops)
  

+{

• struct cscfg_csdev_register *list_entry;
• /* allocate the list entry structure */
• list_entry = kzalloc(sizeof(struct cscfg_csdev_register), GFP_KERNEL);
• if (!list_entry)

• return -ENOMEM;
  

• list_entry->csdev = csdev;
• list_entry->match_info.match_flags = info->match_flags;
• list_entry->ops.load_feat = ops->load_feat;
• list_add(&list_entry->item, &cscfg_mgr->data.csdev_desc_list);
• INIT_LIST_HEAD(&csdev->feature_csdev_list);
• INIT_LIST_HEAD(&csdev->config_csdev_list);
• cscfg_mgr->data.nr_csdev++;
• return 0;

+}

+/* remove a coresight device from the list and free data */ +static void cscfg_list_remove_csdev(struct coresight_device *csdev) +{

• struct cscfg_csdev_register *curr_item, *tmp;
• list_for_each_entry_safe(curr_item, tmp, &cscfg_mgr->data.csdev_desc_list, item) {

• if (curr_item->csdev == csdev) {
  

• 	list_del(&curr_item->item);
  

• 	kfree(curr_item);
  

• 	cscfg_mgr->data.nr_csdev--;
  

• 	break;
  

• }
  

• }

+}

+/* register a coresight device with the syscfg api */ +int cscfg_register_csdev(struct coresight_device *csdev,

• 	 struct cscfg_match_desc *info,
  

• 	 struct cscfg_csdev_feat_ops *ops)
  

+{

• int ret = 0;
• mutex_lock(&cscfg_mutex);
• /* add device to list of registered devices */
• ret = cscfg_list_add_csdev(csdev, info, ops);
• if (ret)

• goto reg_csdev_unlock;
  

• /* now load any registered features and configs matching the device. */
• ret = cscfg_add_feats_csdev(csdev, info, ops);
• if (ret) {

• cscfg_list_remove_csdev(csdev);
  

• goto reg_csdev_unlock;
  

• }
• ret = cscfg_add_cfgs_csdev(csdev, info);
• if (ret) {

• cscfg_list_remove_csdev(csdev);
  

• goto reg_csdev_unlock;
  

• }
• pr_info("CSCFG registered %s", dev_name(&csdev->dev));

+reg_csdev_unlock:

• mutex_unlock(&cscfg_mutex);
• return ret;

+} +EXPORT_SYMBOL_GPL(cscfg_register_csdev);

+/* remove coresight device and update counts - syscfg device at 0 */ +void cscfg_unregister_csdev(struct coresight_device *csdev) +{

• struct cscfg_csdev_register *curr_item, *tmp;
• mutex_lock(&cscfg_mutex);
• list_for_each_entry_safe(curr_item, tmp, &cscfg_mgr->data.csdev_desc_list, item) {

• if (curr_item->csdev == csdev) {
  

• 	list_del(&curr_item->item);
  

• 	kfree(curr_item);
  

• 	cscfg_mgr->data.nr_csdev--;
  

• 	break;
  

• }
  

• }
• mutex_unlock(&cscfg_mutex);

+} +EXPORT_SYMBOL_GPL(cscfg_unregister_csdev);

/* Initialise system configuration management device. */ struct device *to_device_cscfg(void) diff --git a/drivers/hwtracing/coresight/coresight-syscfg.h b/drivers/hwtracing/coresight/coresight-syscfg.h index 907ba8d3efea..ebf5e1491d86 100644 --- a/drivers/hwtracing/coresight/coresight-syscfg.h +++ b/drivers/hwtracing/coresight/coresight-syscfg.h @@ -26,6 +26,22 @@ struct cscfg_api_data { int nr_csdev; }; +/**

• • List entry for Coresight devices that are registered as supporting complex
• • config operations.
• • @csdev: The registered device.
• • @match_info: The matching type information.
• • @ops: Operations supported by the registered device.
• • @item: list entry.
• */

+struct cscfg_csdev_register {

• struct coresight_device *csdev;
• struct cscfg_match_desc match_info;
• struct cscfg_csdev_feat_ops ops;
• struct list_head item;

+};

/* internal core operations for cscfg */ int __init cscfg_init(void); void __exit cscfg_exit(void); @@ -33,6 +49,10 @@ void __exit cscfg_exit(void); /* syscfg manager external API */ int cscfg_load_config_sets(struct cscfg_config_desc **cfg_descs, struct cscfg_feature_desc **feat_descs); +int cscfg_register_csdev(struct coresight_device *csdev,

• 	 struct cscfg_match_desc *info,
  

• 	 struct cscfg_csdev_feat_ops *ops);
  

+void cscfg_unregister_csdev(struct coresight_device *csdev); /**

• System configuration manager device.

diff --git a/include/linux/coresight.h b/include/linux/coresight.h index 976ec2697610..d0126ed326a6 100644 --- a/include/linux/coresight.h +++ b/include/linux/coresight.h @@ -219,6 +219,8 @@ struct coresight_sysfs_link {

• @nr_links: number of sysfs links created to other components from this

• device. These will appear in the "connections" group.
  

• @has_conns_grp: Have added a "connections" group for sysfs links.

• • @feature_csdev_list: List of complex feature programming added to the device.
• • @config_csdev_list: List of system configurations added to the device.
  */

struct coresight_device { struct coresight_platform_data *pdata; @@ -240,6 +242,9 @@ struct coresight_device { int nr_links; bool has_conns_grp; bool ect_enabled; /* true only if associated ect device is enabled */

• /* system configuration and feature lists */
• struct list_head feature_csdev_list;
• struct list_head config_csdev_list;

}; /* -- 2.17.1

On Thu, Jan 28, 2021 at 05:09:30PM +0000, Mike Leach wrote:

Loaded coresight configurations are registered in the cs_etm\cs_config sub directory. This extends the etm-perf code to handle these registrations, and the cs_syscfg driver to perform the registration on load.

Signed-off-by: Mike Leach mike.leach@linaro.org

.../hwtracing/coresight/coresight-config.h | 5 +- .../hwtracing/coresight/coresight-etm-perf.c | 164 +++++++++++++++--- .../hwtracing/coresight/coresight-etm-perf.h | 8 + .../hwtracing/coresight/coresight-syscfg.c | 13 +- 4 files changed, 166 insertions(+), 24 deletions(-)

diff --git a/drivers/hwtracing/coresight/coresight-config.h b/drivers/hwtracing/coresight/coresight-config.h index 9d66e0071f38..98380b496046 100644 --- a/drivers/hwtracing/coresight/coresight-config.h +++ b/drivers/hwtracing/coresight/coresight-config.h @@ -154,7 +154,8 @@ struct cscfg_config_feat_ref {

• @nr_presets: Number of sets of presets supplied by this configuration.
• @nr_total_params: Sum of all parameters declared by used features
• @presets: Array of preset values.

• • @id_ea: Extended attribute for perf configid value
• • @event_ea: Extended attribute for perf event value
  */

struct cscfg_config_desc { const char *name; @@ -165,6 +166,8 @@ struct cscfg_config_desc { int nr_presets; int nr_total_params; const u64 *presets; /* nr_presets * nr_total_params */

• struct dev_ext_attribute *id_ea;
• struct dev_ext_attribute *event_ea;

}; /** diff --git a/drivers/hwtracing/coresight/coresight-etm-perf.c b/drivers/hwtracing/coresight/coresight-etm-perf.c index a608081bd446..e270bb1e0f7d 100644 --- a/drivers/hwtracing/coresight/coresight-etm-perf.c +++ b/drivers/hwtracing/coresight/coresight-etm-perf.c @@ -18,8 +18,10 @@ #include <linux/types.h> #include <linux/workqueue.h> +#include "coresight-config.h" #include "coresight-etm-perf.h" #include "coresight-priv.h" +#include "coresight-syscfg.h" static struct pmu etm_pmu; static bool etm_perf_up; @@ -32,8 +34,13 @@ PMU_FORMAT_ATTR(cycacc, "config:" __stringify(ETM_OPT_CYCACC)); PMU_FORMAT_ATTR(contextid, "config:" __stringify(ETM_OPT_CTXTID)); PMU_FORMAT_ATTR(timestamp, "config:" __stringify(ETM_OPT_TS)); PMU_FORMAT_ATTR(retstack, "config:" __stringify(ETM_OPT_RETSTK)); +/* preset - if sink ID is used as a configuration selector */ +PMU_FORMAT_ATTR(preset, "config:0-3"); /* Sink ID - same for all ETMs */ PMU_FORMAT_ATTR(sinkid, "config2:0-31"); +/* config ID - set if a system configuration is selected */ +PMU_FORMAT_ATTR(configid, "config2:32-63");

static struct attribute *etm_config_formats_attr[] = { &format_attr_cycacc.attr, @@ -41,6 +48,8 @@ static struct attribute *etm_config_formats_attr[] = { &format_attr_timestamp.attr, &format_attr_retstack.attr, &format_attr_sinkid.attr,

• &format_attr_preset.attr,
• &format_attr_configid.attr, NULL,

}; @@ -58,9 +67,29 @@ static const struct attribute_group etm_pmu_sinks_group = { .attrs = etm_config_sinks_attr, }; +static struct attribute *etm_config_cscfg_attr[] = {

• NULL,

+};

+static const struct attribute_group etm_pmu_cscfg_group = {

• .name = "configurations",
• .attrs = etm_config_cscfg_attr,

+};

+static struct attribute *etm_config_events_attr[] = {

• NULL,

+};

+static const struct attribute_group etm_pmu_events_group = {

• .name = "events",
• .attrs = etm_config_events_attr,

+};

static const struct attribute_group *etm_pmu_attr_groups[] = { &etm_pmu_format_group, &etm_pmu_sinks_group,

• &etm_pmu_cscfg_group,
• &etm_pmu_events_group, NULL,

}; @@ -219,7 +248,7 @@ static void *etm_setup_aux(struct perf_event *event, void **pages, INIT_WORK(&event_data->work, free_event_data); /* First get the selected sink from user space. */

• if (event->attr.config2) {

• if (event->attr.config2 & GENMASK_ULL(31, 0)) { id = (u32)event->attr.config2; sink = coresight_get_sink_by_id(id); }

@@ -537,21 +566,17 @@ static ssize_t etm_perf_sink_name_show(struct device *dev,

I would rename this to etm_perf_name_show() so that it doesn't look bizarre when finding it in etm_perf_add_symlink_group().

return scnprintf(buf, PAGE_SIZE, "0x%lx\n", (unsigned long)(ea->var)); } -int etm_perf_add_symlink_sink(struct coresight_device *csdev) +int etm_perf_add_symlink_group(struct device *dev,

• 	       struct dev_ext_attribute **ext_attr,
  

• 	       const char *name,
  

• 	       const char *group_name)
  

{

• int ret;

• struct dev_ext_attribute *ea; unsigned long hash;

• const char *name;

• int ret; struct device *pmu_dev = etm_pmu.dev;

• struct device *dev = &csdev->dev;
• struct dev_ext_attribute *ea;

• if (csdev->type != CORESIGHT_DEV_TYPE_SINK &&

•    csdev->type != CORESIGHT_DEV_TYPE_LINKSINK)
  

• return -EINVAL;
  

• if (csdev->ea != NULL)

• return -EINVAL;
  

• *ext_attr = NULL;

if (!etm_perf_up) return -EPROBE_DEFER; @@ -560,7 +585,6 @@ int etm_perf_add_symlink_sink(struct coresight_device *csdev) if (!ea) return -ENOMEM;

• name = dev_name(dev); /* See function coresight_get_sink_by_id() to know where this is used */

I would also update this comment. If @name is a sink then the hash will be used in coresight_get_sink_by_id(), and if it is a configuration it will be used in etm_perf_add_cscfg_event() and cscfg_activate_config().

hash = hashlen_hash(hashlen_string(NULL, name)); @@ -574,31 +598,127 @@ int etm_perf_add_symlink_sink(struct coresight_device *csdev) ea->var = (unsigned long *)hash; ret = sysfs_add_file_to_group(&pmu_dev->kobj,

• 		      &ea->attr.attr, "sinks");
  

• 		      &ea->attr.attr, group_name);
  

  if (!ret)

• csdev->ea = ea;
  

• *ext_attr = ea;
  

  return ret;

} -void etm_perf_del_symlink_sink(struct coresight_device *csdev) +int etm_perf_add_symlink_sink(struct coresight_device *csdev) +{

• const char *name;
• struct device *dev = &csdev->dev;
• if (csdev->type != CORESIGHT_DEV_TYPE_SINK &&

•    csdev->type != CORESIGHT_DEV_TYPE_LINKSINK)
  

• return -EINVAL;
  

• if (csdev->ea != NULL)

• return -EINVAL;
  

• name = dev_name(dev);
• return etm_perf_add_symlink_group(dev, &csdev->ea, name, "sinks");

+}

+void etm_perf_del_symlink_group(struct dev_ext_attribute *ea, const char *group_name) { struct device *pmu_dev = etm_pmu.dev;

• struct dev_ext_attribute *ea = csdev->ea;

• sysfs_remove_file_from_group(&pmu_dev->kobj,

• 		     &ea->attr.attr, group_name);
  

+}

+void etm_perf_del_symlink_sink(struct coresight_device *csdev) +{ if (csdev->type != CORESIGHT_DEV_TYPE_SINK && csdev->type != CORESIGHT_DEV_TYPE_LINKSINK) return;

• if (!ea)

• if (!csdev->ea) return;

• sysfs_remove_file_from_group(&pmu_dev->kobj,

• 		     &ea->attr.attr, "sinks");
  

• etm_perf_del_symlink_group(csdev->ea, "sinks"); csdev->ea = NULL;

} +/* string to contain the attribute value */ +#define CSCFG_EVENT_STR_SIZE 32

+static ssize_t etm_perf_cscfg_event_show(struct device *dev,

• 			 struct device_attribute *dattr,
  

• 			 char *buf)
  

+{

• struct dev_ext_attribute *ea;
• ea = container_of(dattr, struct dev_ext_attribute, attr);
• return scnprintf(buf, PAGE_SIZE, "%s\n", (const char *)(ea->var));

+}

+static int etm_perf_add_cscfg_event(struct device *dev, struct cscfg_config_desc *cs_cfg) +{

• struct dev_ext_attribute *ea;
• unsigned long hash;
• int ret;
• struct device *pmu_dev = etm_pmu.dev;
• ea = devm_kzalloc(dev, sizeof(*ea), GFP_KERNEL);
• if (!ea)

• return -ENOMEM;
  

• hash = (unsigned long)cs_cfg->id_ea->var;
• sysfs_attr_init(&ea->attr.attr);
• ea->attr.attr.name = devm_kstrdup(dev, cs_cfg->name, GFP_KERNEL);
• if (!ea->attr.attr.name)

• return -ENOMEM;
  

• /*

• * attribute value is "configid=<hash>".
  

• * this will be what perf evaluates when the config name is used
  

• * on the command line.
  

• */
  

• ea->var = devm_kzalloc(dev, CSCFG_EVENT_STR_SIZE, GFP_KERNEL);
• if (!ea->var)

• return -ENOMEM;
  

• scnprintf(ea->var, CSCFG_EVENT_STR_SIZE, "configid=0x%lx", hash);
• ea->attr.attr.mode = 0444;
• ea->attr.show = etm_perf_cscfg_event_show;
• ret = sysfs_add_file_to_group(&pmu_dev->kobj,

• 		      &ea->attr.attr, "events");
  

• if (!ret)

• cs_cfg->event_ea = ea;
  

• return ret;

+}

+int etm_perf_add_symlink_cscfg(struct device *dev, struct cscfg_config_desc *cs_cfg) +{

• int err;
• if (cs_cfg->id_ea != NULL)

• return 0;
  

• err = etm_perf_add_symlink_group(dev, &cs_cfg->id_ea,

• 			 cs_cfg->name, "configurations");
  

Do we need configurations to be advertised under /sys/bus/event_source/devices/cs_etm given that they are already found in /sys/kernel/config/coresight-syscfg? And the events already carry the hash if someone is really keen using the "configid=" syntax.

In my opinion we can get by with what is in configfs and do away with the "configurations" directory here.

• if (!err)

• err = etm_perf_add_cscfg_event(dev, cs_cfg);
  

That we definitely need.

Thanks, Mathieu

• return err;

+}

+void etm_perf_del_symlink_cscfg(struct cscfg_config_desc *cs_cfg) +{

• if (!cs_cfg->id_ea)

• return;
  

• etm_perf_del_symlink_group(cs_cfg->id_ea, "configurations");
• etm_perf_del_symlink_group(cs_cfg->event_ea, "events");
• cs_cfg->id_ea = NULL;
• cs_cfg->event_ea = NULL;

+}

int __init etm_perf_init(void) { int ret; diff --git a/drivers/hwtracing/coresight/coresight-etm-perf.h b/drivers/hwtracing/coresight/coresight-etm-perf.h index 29d90dfeba31..3646a3837a0b 100644 --- a/drivers/hwtracing/coresight/coresight-etm-perf.h +++ b/drivers/hwtracing/coresight/coresight-etm-perf.h @@ -11,6 +11,7 @@ #include "coresight-priv.h" struct coresight_device; +struct cscfg_config_desc; /*

• In both ETMv3 and v4 the maximum number of address comparator implentable

@@ -69,6 +70,9 @@ static inline void *etm_perf_sink_config(struct perf_output_handle *handle) return data->snk_config; return NULL; } +int etm_perf_add_symlink_cscfg(struct device *dev,

• 	       struct cscfg_config_desc *cscfg_desc);
  

+void etm_perf_del_symlink_cscfg(struct cscfg_config_desc *cscfg_desc); #else static inline int etm_perf_symlink(struct coresight_device *csdev, bool link) { return -EINVAL; } @@ -79,6 +83,10 @@ static inline void *etm_perf_sink_config(struct perf_output_handle *handle) { return NULL; } +int etm_perf_add_symlink_cscfg(struct device *dev,

• 	       struct cscfg_config_desc *cscfg_desc)
  

+{ return -EINVAL; } +void etm_perf_del_symlink_cscfg(struct cscfg_config_desc *cscfg_desc) {} #endif /* CONFIG_CORESIGHT */ diff --git a/drivers/hwtracing/coresight/coresight-syscfg.c b/drivers/hwtracing/coresight/coresight-syscfg.c index 4b8e4e35e3e7..a070f135eca3 100644 --- a/drivers/hwtracing/coresight/coresight-syscfg.c +++ b/drivers/hwtracing/coresight/coresight-syscfg.c @@ -7,6 +7,7 @@ #include <linux/platform_device.h> #include "coresight-config.h" +#include "coresight-etm-perf.h" #include "coresight-syscfg.h" /* @@ -100,6 +101,7 @@ static int cscfg_add_csdev_cfg(struct coresight_device *csdev, dev_cfg->feats[dev_cfg->nr_feat++] = feat; } }

• /* if matched features, add config to device.*/ if (dev_cfg) { mutex_lock(&cscfg_csdev_mutex);

@@ -290,8 +292,12 @@ static int cscfg_load_config(struct cscfg_config_desc *cfg_desc) if (err) return err;

• list_add(&cfg_desc->item, &cscfg_mgr->data.config_desc_list);

• /* add config to perf fs to allow selection */
• err = etm_perf_add_symlink_cscfg(to_device_cscfg(), cfg_desc);
• if (err)

• return err;
  

• list_add(&cfg_desc->item, &cscfg_mgr->data.config_desc_list); return 0;

} @@ -517,7 +523,12 @@ int cscfg_create_device(void) void cscfg_clear_device(void) {

• struct cscfg_config_desc *cfg_desc;
• mutex_lock(&cscfg_mutex);
• list_for_each_entry(cfg_desc, &cscfg_mgr->data.config_desc_list, item) {

• etm_perf_del_symlink_cscfg(cfg_desc);
  

• } device_unregister(to_device_cscfg()); mutex_unlock(&cscfg_mutex);

}

2.17.1

---

linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

[...]

...

+/**

• • Mark a config descriptor as active.
• • This will be seen when csdev devices are activated in the system.
• • Selection by hash value - generated from the configuration name when it
• • was loaded and added to the cs_etm/configurations file system for selection
• • by perf.
• • @cfg_hash: Hash value of the selected configuration name.
• */

+int cscfg_activate_config(unsigned long cfg_hash) +{

• struct cscfg_config_desc *curr_item, *match_item = 0;
• mutex_lock(&cscfg_mutex);
• list_for_each_entry(curr_item, &cscfg_mgr->data.config_desc_list, item) {

• if ((unsigned long)curr_item->id_ea->var == cfg_hash) {
  

• 	match_item = curr_item;
  

• 	atomic_inc(&cscfg_mgr->data.sys_active_cnt);
  

It would be nice to have a comment that mentions why this is needed. I had to go look in patch 09 to see that it prevents a feature from being changed when any configuration is active. And since patch 09 is the only place where @sys_active_cnt is used, please move the declaration and handling of the variable there.

...

• 	break;
  

• }
  

• }
• mutex_unlock(&cscfg_mutex);
• if (!match_item)

• return -EINVAL;
  

• dev_dbg(to_device_cscfg(), "Activate config %s.\n", match_item->name);
• /* mark the descriptors as active so enable config will use them */
• mutex_lock(&cscfg_csdev_mutex);
• atomic_inc(&match_item->active_cnt);

What is ->active_cnt used for? I see it referenced in cscfg_csdev_enable_active_config() but it doesn't do much other than to confirm the configuration has been activated by someone.

There is also a chance that a caller would call cscfg_activate_config() once and call cscfg_csdev_enable_active_config() multiple time, which would really create problems. I would move the incrementation of sys_active_cnt within the mutex hold in cscfg_csdev_enable_active_config() and get rid of ->active_cnt. If I am correct we wouldn't need cscfg_activate_config() after that.

I looked at patch 06 and I understand why incrementing sys_active_cnt has to be done before enabling it. If it wasn't so someone could update the feature between the time setup_aux() is called and the event is installed on a CPU. As such cscfg_activate_config() should stay but I still think ->active_cnt should go.

...

• mutex_unlock(&cscfg_csdev_mutex);
• return 0;

+} +EXPORT_SYMBOL_GPL(cscfg_activate_config);

+void cscfg_deactivate_config(unsigned long cfg_hash)

I'm fine with either cfg_hash or id_hash, but not both.

...

+{

• struct cscfg_config_desc *curr_item, *match_item = 0;
• mutex_lock(&cscfg_mutex);
• list_for_each_entry(curr_item, &cscfg_mgr->data.config_desc_list, item) {

• if ((unsigned long)curr_item->id_ea->var == cfg_hash) {
  

• 	match_item = curr_item;
  

• 	break;
  

• }
  

• }
• mutex_unlock(&cscfg_mutex);
• if (!match_item)

• return;
  

• dev_dbg(to_device_cscfg(), "Deactivate config %s.\n", match_item->name);
• mutex_lock(&cscfg_csdev_mutex);
• atomic_dec(&match_item->active_cnt);
• mutex_unlock(&cscfg_csdev_mutex);
• atomic_dec(&cscfg_mgr->data.sys_active_cnt);

+} +EXPORT_SYMBOL_GPL(cscfg_deactivate_config);

+/* Find and program any active config for the supplied device.*/ +int cscfg_csdev_enable_active_config(struct coresight_device *csdev,

• 		     unsigned long id_hash, int preset)
  

+{

• struct cscfg_config_csdev *cfg = NULL, *item;
• const struct cscfg_config_desc *desc;
• int err = 0;
• /* quickly check global count */
• if (!atomic_read(&cscfg_mgr->data.sys_active_cnt))

• return 0;
  

• mutex_lock(&cscfg_csdev_mutex);
• list_for_each_entry(item, &csdev->config_csdev_list, node) {

• desc = item->desc;
  

• if ((atomic_read(&desc->active_cnt)) &&
  

•     ((unsigned long)desc->id_ea->var == id_hash)) {
  

• 	cfg = item;
  

• 	break;
  

• }
  

• }
• if (cfg) {

• err = cscfg_csdev_enable_config(cfg, preset);
  

• if (!err)
  

• 	csdev->active_cfg_ctxt = (void *)cfg;
  

• }
• mutex_unlock(&cscfg_csdev_mutex);
• return err;

+} +EXPORT_SYMBOL_GPL(cscfg_csdev_enable_active_config);

+/* save and disable the active config for the device */ +void cscfg_csdev_disable_active_config(struct coresight_device *csdev) +{

• struct cscfg_config_csdev *cfg;
• mutex_lock(&cscfg_csdev_mutex);
• cfg = (struct cscfg_config_csdev *)csdev->active_cfg_ctxt;
• if (cfg)

• cscfg_csdev_disable_config(cfg);
  

• mutex_unlock(&cscfg_csdev_mutex);

+} +EXPORT_SYMBOL_GPL(cscfg_csdev_disable_active_config);

/* Initialise system configuration management device. */ struct device *to_device_cscfg(void) @@ -546,6 +672,7 @@ int __init cscfg_init(void) INIT_LIST_HEAD(&cscfg_mgr->data.feat_desc_list); INIT_LIST_HEAD(&cscfg_mgr->data.config_desc_list); cscfg_mgr->data.nr_csdev = 0;

• atomic_set(&cscfg_mgr->data.sys_active_cnt, 0);

dev_info(to_device_cscfg(), "CoreSight Configuration manager initialised"); return 0; diff --git a/drivers/hwtracing/coresight/coresight-syscfg.h b/drivers/hwtracing/coresight/coresight-syscfg.h index ebf5e1491d86..301e26e1e98f 100644 --- a/drivers/hwtracing/coresight/coresight-syscfg.h +++ b/drivers/hwtracing/coresight/coresight-syscfg.h @@ -17,13 +17,15 @@

• @csdev_list: List of coresight devices registered with the configuration manager.
• @feat_desc_list: List of feature descriptors to load into registered devices.
• @config_desc_list: List of system configuration descriptors to load into registered devices.

• • @nr_csdev: Number of registered devices with the cscfg system

• • @nr_csdev: Number of registered devices with the cscfg system
• • @sys_active_cnt: Total number of active config descriptor references.
  */

struct cscfg_api_data { struct list_head csdev_desc_list; struct list_head feat_desc_list; struct list_head config_desc_list; int nr_csdev;

• atomic_t sys_active_cnt;

}; /** @@ -53,6 +55,12 @@ int cscfg_register_csdev(struct coresight_device *csdev, struct cscfg_match_desc *info, struct cscfg_csdev_feat_ops *ops); void cscfg_unregister_csdev(struct coresight_device *csdev); +int cscfg_activate_config(unsigned long cfg_hash); +void cscfg_deactivate_config(unsigned long cfg_hash); +void cscfg_csdev_reset_feats(struct coresight_device *csdev); +int cscfg_csdev_enable_active_config(struct coresight_device *csdev,

• 		     unsigned long id_hash, int preset);
  

+void cscfg_csdev_disable_active_config(struct coresight_device *csdev); /**

• System configuration manager device.

diff --git a/include/linux/coresight.h b/include/linux/coresight.h index d0126ed326a6..3941854e8280 100644 --- a/include/linux/coresight.h +++ b/include/linux/coresight.h @@ -221,6 +221,7 @@ struct coresight_sysfs_link {

• @has_conns_grp: Have added a "connections" group for sysfs links.
• @feature_csdev_list: List of complex feature programming added to the device.
• @config_csdev_list: List of system configurations added to the device.

• • @active_cfg_ctxt: Context information for current active congfig.
  */

struct coresight_device { struct coresight_platform_data *pdata; @@ -245,6 +246,7 @@ struct coresight_device { /* system configuration and feature lists */ struct list_head feature_csdev_list; struct list_head config_csdev_list;

• void *active_cfg_ctxt;

}; /* -- 2.17.1

Hi Mathieu,

On Thu, 18 Feb 2021 at 23:52, Mathieu Poirier mathieu.poirier@linaro.org wrote:

On Thu, Jan 28, 2021 at 05:09:27PM +0000, Mike Leach wrote:

...

Creates an system management API to allow complex configurations and features to be programmed into a CoreSight infrastructure.

A feature is defined as a programming set for a device or class of devices.

A configuration is a set of features across the system that are enabled for a trace session.

The API will manage system wide configuration, and allow complex programmed features to be added to individual device instances, and provide for system wide configuration selection on trace capture operations.

This patch creates the initial data object and the initial API for loading configurations and features.

Signed-off-by: Mike Leach mike.leach@linaro.org

drivers/hwtracing/coresight/Makefile | 2 +- .../hwtracing/coresight/coresight-config.h | 167 +++++++++++++++ drivers/hwtracing/coresight/coresight-core.c | 12 +- .../hwtracing/coresight/coresight-etm-perf.c | 2 +- .../hwtracing/coresight/coresight-etm-perf.h | 2 +- .../hwtracing/coresight/coresight-syscfg.c | 197 ++++++++++++++++++ .../hwtracing/coresight/coresight-syscfg.h | 54 +++++ 7 files changed, 432 insertions(+), 4 deletions(-) create mode 100644 drivers/hwtracing/coresight/coresight-config.h create mode 100644 drivers/hwtracing/coresight/coresight-syscfg.c create mode 100644 drivers/hwtracing/coresight/coresight-syscfg.h

diff --git a/drivers/hwtracing/coresight/Makefile b/drivers/hwtracing/coresight/Makefile index f20e357758d1..4ce854c434b1 100644 --- a/drivers/hwtracing/coresight/Makefile +++ b/drivers/hwtracing/coresight/Makefile @@ -4,7 +4,7 @@ # obj-$(CONFIG_CORESIGHT) += coresight.o coresight-y := coresight-core.o coresight-etm-perf.o coresight-platform.o \

•         coresight-sysfs.o
  

•         coresight-sysfs.o coresight-syscfg.o
  

obj-$(CONFIG_CORESIGHT_LINK_AND_SINK_TMC) += coresight-tmc.o coresight-tmc-y := coresight-tmc-core.o coresight-tmc-etf.o \ coresight-tmc-etr.o diff --git a/drivers/hwtracing/coresight/coresight-config.h b/drivers/hwtracing/coresight/coresight-config.h new file mode 100644 index 000000000000..3fedf8ab3cee --- /dev/null +++ b/drivers/hwtracing/coresight/coresight-config.h @@ -0,0 +1,167 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/*

• • Copyright (c) 2020 Linaro Limited, All rights reserved.
• • Author: Mike Leach mike.leach@linaro.org
• */

+#ifndef _CORESIGHT_CORESIGHT_CONFIG_H +#define _CORESIGHT_CORESIGHT_CONFIG_H

+#include <linux/coresight.h> +#include <linux/types.h>

+/* CoreSight Configuration Management - component and system wide configuration */

+/*

• • Register type flags for register value descriptor:
• • describe how the value is interpreted, and handled.
• */

+#define CS_CFG_REG_TYPE_STD 0x80 /* reg is standard reg */ +#define CS_CFG_REG_TYPE_RESOURCE 0x40 /* reg is a resource */ +#define CS_CFG_REG_TYPE_VAL_PARAM 0x08 /* reg value uses param */ +#define CS_CFG_REG_TYPE_VAL_MASK 0x04 /* reg value bit masked */ +#define CS_CFG_REG_TYPE_VAL_64BIT 0x02 /* reg value 64 bit */ +#define CS_CFG_REG_TYPE_VAL_SAVE 0x01 /* reg value save on disable */

+/*

• • flags defining what device class a feature will match to when processing a
• • system configuration - used by config data and devices.
• */

+#define CS_CFG_MATCH_CLASS_SRC_ALL 0x0001 /* match any source */ +#define CS_CFG_MATCH_CLASS_SRC_ETM4 0x0002 /* match any ETMv4 device */

+/* flags defining device instance matching - used in config match desc data. */ +#define CS_CFG_MATCH_INST_ANY 0x80000000 /* any instance of a class */

+/*

• • Limit number of presets in a configuration
• • This is related to the number of bits (4) we use to select the preset on
• • the perf command line. Preset 0 is always none selected.
• • See PMU_FORMAT_ATTR(preset, "config:0-3") in coresight-etm-perf.c
• */

+#define CS_CFG_CONFIG_PRESET_MAX 15

+/**

• • Parameter descriptor for a device feature.
• • @name: Name of parameter.
• • @value: Initial or default value.
• */

+struct cscfg_parameter_desc {

• const char *name;
  

• u64 value;
  

+};

+/**

• • Representation of register value.
• • Supports full 64 bit register value, or 32 bit value with optional mask
• • value.
• • @type: define register usage and interpretation.
• • @offset: the address offset for register in the hardware device (per device specification).
• • @hw_info: optional hardware device type specific information. (ETM / CTI specific etc)
• • @val64: 64 bit value.
• • @val32: 32 bit value.
• • @mask32: 32 bit mask when using 32 bit value to access device register.
• */

+struct cscfg_regval_desc {

• struct {
  

•         u32 type:8;
  

•         u32 offset:12;
  

•         u32 hw_info:12;
  

• };
  

• union {
  

•         u64 val64;
  

•         struct {
  

•                 u32 val32;
  

•                 u32 mask32;
  

•         };
  

• };
  

+};

+/**

• • Device feature descriptor - combination of registers and parameters to
• • program a device to implement a specific complex function.
• • @name: feature name.
• • @brief: brief description of the feature.
• • @item: List entry.
• • @match_flags: matching information if loading into a device
• • @nr_params: number of parameters used.
• • @params: array of parameters used.
• • @nr_regs: number of registers used.
• • @reg: array of registers used.
• */

+struct cscfg_feature_desc {

• const char *name;
  

• const char *brief;
  

• struct list_head item;
  

• u32 match_flags;
  

• int nr_params;
  

• struct cscfg_parameter_desc *params;
  

• int nr_regs;
  

• struct cscfg_regval_desc *regs;
  

+};

+/**

• • Match descriptor - Device / feature matching when loading into devices
• • Used by loading configurations to define which class or specific devices
• • they want to match used features to, and registered devices to specify which
• • matching class and information they support.
• • The load process uses these matching pairs to load feature instances into
• • matching devices.
• • @match_flags: used to match to a particular class of device.
• */

+struct cscfg_match_desc {

• u32 match_flags;
  

+};

+/**

• • Descriptor for features referenced by a configuration.
• • @name: name of feature to use. Match against the @name in struct

• •       cscfg_feature_desc.
    

• • @match: match info for the feature when used in this configuration -

• •       may be all devices of a class or a specific device in that class.
    

• */

+struct cscfg_config_feat_ref {

• const char *name;
  

• struct cscfg_match_desc match;
  

I would get rid of structure cscfg_match_desc and put @match_flags right here.

How often do you envision features having different matches for different configuration? If there is no real use for it we could use @name and @match_flags from structure cscfg_feature_desck and get rid of cscfg_config_feat_ref entirely.

I've been giving this some consideration - features really need the match flags - they ensure hardware compatibility. Configs - a simple select by name should be sufficient. Both will need the ability to match to specific devices - e.g. a system CTI will be connected differently than all the standard "cpu" CTIs, but this can be acheived for configurations at least by way of extending the naming - e.g. "feature" selects the feature on any device that supports it, "feature.device" selects the feature on a specific device. So yes - we can drop cscfg_config_feat_ref and probably cscfg_match_desc as the match info will only appear in the feature_desc.

...

+};

+/**

• • Configuration descriptor - describes selectable system configuration.
• • A configuration describes device features in use, and may provide preset
• • values for the parameters in those features.
• • A single set of presets is the sum of the parameters declared by
• • all the features in use - this value is @nr_total_params.
• • @name: name of the configuration - used for selection.
• • @brief: description of the purpose of the configuration.
• • @item: list entry.
• • @nr_refs: Number of features used in this configuration.
• • @refs: references to features used in this configuration..
• • @nr_presets: Number of sets of presets supplied by this configuration.
• • @nr_total_params: Sum of all parameters declared by used features
• • @presets: Array of preset values.
• */

+struct cscfg_config_desc {

• const char *name;
  

• const char *brief;
  

• struct list_head item;
  

• int nr_refs;
  

• struct cscfg_config_feat_ref *refs;
  

• int nr_presets;
  

• int nr_total_params;
  

• const u64 *presets; /* nr_presets * nr_total_params */
  

+};

+#endif /* _CORESIGHT_CORESIGHT_CONFIG_H */ diff --git a/drivers/hwtracing/coresight/coresight-core.c b/drivers/hwtracing/coresight/coresight-core.c index 0062c8935653..6bd41de46648 100644 --- a/drivers/hwtracing/coresight/coresight-core.c +++ b/drivers/hwtracing/coresight/coresight-core.c @@ -21,6 +21,7 @@

#include "coresight-etm-perf.h" #include "coresight-priv.h" +#include "coresight-syscfg.h"

static DEFINE_MUTEX(coresight_mutex);

@@ -1739,13 +1740,22 @@ static int __init coresight_init(void)

  ret = etm_perf_init();
  if (ret)

•         bus_unregister(&coresight_bustype);
  

•         goto exit_bus_unregister;
  
  

• /* initialise the coresight syscfg API */
  

• ret = cscfg_init();
  

• if (!ret)
  

•         return 0;
  

• etm_perf_exit();
  

+exit_bus_unregister:

• bus_unregister(&coresight_bustype);
  return ret;
  

}

static void __exit coresight_exit(void) {

• cscfg_exit();
  etm_perf_exit();
  bus_unregister(&coresight_bustype);
  

} diff --git a/drivers/hwtracing/coresight/coresight-etm-perf.c b/drivers/hwtracing/coresight/coresight-etm-perf.c index bdc34ca449f7..a608081bd446 100644 --- a/drivers/hwtracing/coresight/coresight-etm-perf.c +++ b/drivers/hwtracing/coresight/coresight-etm-perf.c @@ -627,7 +627,7 @@ int __init etm_perf_init(void) return ret; }

-void __exit etm_perf_exit(void) +void etm_perf_exit(void) { perf_pmu_unregister(&etm_pmu); }

Ok

...

diff --git a/drivers/hwtracing/coresight/coresight-etm-perf.h b/drivers/hwtracing/coresight/coresight-etm-perf.h index 3e4f2ad5e193..29d90dfeba31 100644 --- a/drivers/hwtracing/coresight/coresight-etm-perf.h +++ b/drivers/hwtracing/coresight/coresight-etm-perf.h @@ -83,6 +83,6 @@ static inline void *etm_perf_sink_config(struct perf_output_handle *handle) #endif /* CONFIG_CORESIGHT */

int __init etm_perf_init(void); -void __exit etm_perf_exit(void); +void etm_perf_exit(void);

Ok

...

#endif diff --git a/drivers/hwtracing/coresight/coresight-syscfg.c b/drivers/hwtracing/coresight/coresight-syscfg.c new file mode 100644 index 000000000000..f7e396a5f9cb --- /dev/null +++ b/drivers/hwtracing/coresight/coresight-syscfg.c @@ -0,0 +1,197 @@ +// SPDX-License-Identifier: GPL-2.0 +/*

• • Copyright (c) 2020 Linaro Limited, All rights reserved.
• • Author: Mike Leach mike.leach@linaro.org
• */

+#include <linux/platform_device.h>

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

+/*

• • cscfg_ API manages configurations and features for the entire coresight
• • infrastructure.
• • It allows the loading of configurations and features, and loads these into
• • coresight devices as appropriate.
• */

+/* protect the cscsg_data and device */ +static DEFINE_MUTEX(cscfg_mutex);

+/* only one of these */ +static struct cscfg_manager *cscfg_mgr;

+/* load features and configuations into the lists */

+/* check feature list for a named feature - call with mutex locked. */ +static bool cscfg_match_list_feat(const char *name) +{

• struct cscfg_feature_desc *curr_item;
  

• list_for_each_entry(curr_item, &cscfg_mgr->data.feat_desc_list, item) {
  

•         if (strcmp(curr_item->name, name) == 0)
  

•                 return true;
  

• }
  

• return false;
  

+}

+/* check all feat needed for cfg are in the list - call with mutex locked. */ +static int cscfg_check_feat_for_cfg(struct cscfg_config_desc *cfg_desc) +{

• int i;
  

• for (i = 0; i < cfg_desc->nr_refs; i++)
  

•         if (!cscfg_match_list_feat(cfg_desc->refs[i].name))
  

•                 return -EINVAL;
  

• return 0;
  

+}

+/*

• • load feature - add to feature list.
• */

+static int cscfg_load_feat(struct cscfg_feature_desc *feat_desc) +{

• list_add(&feat_desc->item, &cscfg_mgr->data.feat_desc_list);
  

• return 0;
  

+}

+/*

• • load config into the system - validate used features exist then add to
• • config list.
• */

+static int cscfg_load_config(struct cscfg_config_desc *cfg_desc) +{

• int err;
  

• /* validate features are present */
  

• err = cscfg_check_feat_for_cfg(cfg_desc);
  

• if (err)
  

•         return err;
  

• list_add(&cfg_desc->item, &cscfg_mgr->data.config_desc_list);
  

• return 0;
  

+}

+/*

• • External API function to load feature and config sets.
• • Take a 0 terminated array of feature descriptors and/or configuration
• • descriptors and load into the system.
• • Features are loaded first to ensure configuration dependencies can be met.
• */

+int cscfg_load_config_sets(struct cscfg_config_desc **cfg_descs,

•                    struct cscfg_feature_desc **feat_descs)
  

+{

• int err, i = 0;
  

• mutex_lock(&cscfg_mutex);
  

• /* load features first */
  

• if (feat_descs) {
  

•         while (feat_descs[i]) {
  

•                 err = cscfg_load_feat(feat_descs[i]);
  

•                 if (err) {
  

•                         pr_err("coresight-syscfg: Failed to load feature %s\n",
  

•                                feat_descs[i]->name);
  

•                         goto do_unlock;
  

•                 }
  

•                 i++;
  

•         }
  

• }
  

• /* next any configurations to check feature dependencies */
  

• i = 0;
  

• if (cfg_descs) {
  

•         while (cfg_descs[i]) {
  

•                 err = cscfg_load_config(cfg_descs[i]);
  

•                 if (err) {
  

•                         pr_err("coresight-syscfg: Failed to load configuration %s\n",
  

•                                cfg_descs[i]->name);
  

•                         goto do_unlock;
  

•                 }
  

•                 i++;
  

•         }
  

• }
  

+do_unlock:

• mutex_unlock(&cscfg_mutex);
  

• return err;
  

+} +EXPORT_SYMBOL_GPL(cscfg_load_config_sets);

+/* Initialise system configuration management device. */

+struct device *to_device_cscfg(void) +{

• return cscfg_mgr ? &cscfg_mgr->dev : NULL;
  

+}

+/* Must have a release function or the kernel will complain on module unload */ +void cscfg_dev_release(struct device *dev) +{

• kfree(cscfg_mgr);
  

• cscfg_mgr = NULL;
  

+}

+/* a device is needed to "own" some kernel elements such as sysfs entries. */ +int cscfg_create_device(void) +{

• struct device *dev;
  

• int err = -ENOMEM;
  

• mutex_lock(&cscfg_mutex);
  

• if (cscfg_mgr) {
  

•         err = -EINVAL;
  

•         goto create_dev_exit_unlock;
  

• }
  

• cscfg_mgr = kzalloc(sizeof(struct cscfg_manager), GFP_KERNEL);
  

• if (!cscfg_mgr)
  

•         goto create_dev_exit_unlock;
  

• /* setup the device */
  

• dev = to_device_cscfg();
  

• dev->release = cscfg_dev_release;
  

• dev->init_name = "system_cfg";
  

• err = device_register(dev);
  

• if (err)
  

•         cscfg_dev_release(dev);
  

+create_dev_exit_unlock:

• mutex_unlock(&cscfg_mutex);
  

• return err;
  

+}

Much cleaner

...

+void cscfg_clear_device(void) +{

• mutex_lock(&cscfg_mutex);
  

• device_unregister(to_device_cscfg());
  

• mutex_unlock(&cscfg_mutex);
  

+}

+/* Initialise system config management API device */ +int __init cscfg_init(void) +{

• int err = 0;
  

• err = cscfg_create_device();
  

• if (err)
  

•         return err;
  

• INIT_LIST_HEAD(&cscfg_mgr->data.csdev_desc_list);
  

• INIT_LIST_HEAD(&cscfg_mgr->data.feat_desc_list);
  

• INIT_LIST_HEAD(&cscfg_mgr->data.config_desc_list);
  

• cscfg_mgr->data.nr_csdev = 0;
  

We are keeping track of the number of cs devices registered with the manager but I don't see a place (in this patchset) where the information is used. If indeed we dont' need it I suggest moving the lists held in cscfg_api_data directly to cscfg_manager.

No the count can be dropped. Its a hangover from some previously dropped design feature. Now we have the manager object, there is no value in the separate data object. I'll subsume the lists and other things that end up in this sturcture directly into the manager.

...

• dev_info(to_device_cscfg(), "CoreSight Configuration manager initialised");
  

• return 0;
  

+}

+void __exit cscfg_exit(void) +{

• cscfg_clear_device();
  

+} diff --git a/drivers/hwtracing/coresight/coresight-syscfg.h b/drivers/hwtracing/coresight/coresight-syscfg.h new file mode 100644 index 000000000000..907ba8d3efea --- /dev/null +++ b/drivers/hwtracing/coresight/coresight-syscfg.h @@ -0,0 +1,54 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/*

• • Coresight system configuration driver.
• */

+#ifndef CORESIGHT_SYSCFG_H +#define CORESIGHT_SYSCFG_H

+#include <linux/coresight.h> +#include <linux/device.h>

+#include "coresight-config.h"

+/**

• • System configuration manager API data.
• • @csdev_list: List of coresight devices registered with the configuration manager.
• • @feat_desc_list: List of feature descriptors to load into registered devices.
• • @config_desc_list: List of system configuration descriptors to load into registered devices.
• • @nr_csdev: Number of registered devices with the cscfg system
• */

+struct cscfg_api_data {

• struct list_head csdev_desc_list;
  

• struct list_head feat_desc_list;
  

• struct list_head config_desc_list;
  

• int nr_csdev;
  

+};

+/* internal core operations for cscfg */ +int __init cscfg_init(void); +void __exit cscfg_exit(void);

+/* syscfg manager external API */ +int cscfg_load_config_sets(struct cscfg_config_desc **cfg_descs,

•                    struct cscfg_feature_desc **feat_descs);
  

+/**

• • System configuration manager device.
• • Need a device to 'own' some coresight system wide sysfs entries in
• • perf events, configfs etc.
• • @dev: The device.
• • @data: The API data.
• */

+struct cscfg_manager {

• struct device dev;
  

• struct cscfg_api_data data;
  

+};

+/* get reference to dev in cscfg_manager */ +struct device *to_device_cscfg(void);

This patch looks really good now. More comments to come tomorrow.

Thanks, Mathieu

...

+#endif /* CORESIGHT_SYSCFG_H */

2.17.1

Thanks for the review

Mike

Hi Mathieu,

On Fri, 19 Feb 2021 at 18:43, Mathieu Poirier mathieu.poirier@linaro.org wrote:

[...]

...

+/**

• • List entry for Coresight devices that are registered as supporting complex
• • config operations.
• • @csdev: The registered device.
• • @match_info: The matching type information.
• • @ops: Operations supported by the registered device.
• • @item: list entry.
• */

+struct cscfg_csdev_register {

• struct coresight_device *csdev;
  

• struct cscfg_match_desc match_info;
  

• struct cscfg_csdev_feat_ops ops;
  

• struct list_head item;
  

+};

I would call this structure cscfg_registered_csdev and move it to coresight-config.h. That way it is consistent with cscfg_config_csdev and cscfg_feature_csdev and located all in the same file.

I was trying to separate structures that are used to define configurations and features, with those that are used to manage the same. Hence, most things in coresight_config.h define configurations, or their device loaded instance equivalents, and things in coresight_syscfg.h are management items. I am happy to change the name but would prefer is stay in coresight_syscfg.h

Thanks

Mike

I may have to come back to this patch but for now it holds together.

More comments to come on Monday.

Thanks, Mathieu

...

/* internal core operations for cscfg */ int __init cscfg_init(void); void __exit cscfg_exit(void); @@ -33,6 +49,10 @@ void __exit cscfg_exit(void); /* syscfg manager external API */ int cscfg_load_config_sets(struct cscfg_config_desc **cfg_descs, struct cscfg_feature_desc **feat_descs); +int cscfg_register_csdev(struct coresight_device *csdev,

•                  struct cscfg_match_desc *info,
  

•                  struct cscfg_csdev_feat_ops *ops);
  

+void cscfg_unregister_csdev(struct coresight_device *csdev);

/**

• System configuration manager device.

diff --git a/include/linux/coresight.h b/include/linux/coresight.h index 976ec2697610..d0126ed326a6 100644 --- a/include/linux/coresight.h +++ b/include/linux/coresight.h @@ -219,6 +219,8 @@ struct coresight_sysfs_link {

• @nr_links: number of sysfs links created to other components from this

•       device. These will appear in the "connections" group.
  

• @has_conns_grp: Have added a "connections" group for sysfs links.

• • @feature_csdev_list: List of complex feature programming added to the device.
• • @config_csdev_list: List of system configurations added to the device.
  */

struct coresight_device { struct coresight_platform_data *pdata; @@ -240,6 +242,9 @@ struct coresight_device { int nr_links; bool has_conns_grp; bool ect_enabled; /* true only if associated ect device is enabled */

• /* system configuration and feature lists */
  

• struct list_head feature_csdev_list;
  

• struct list_head config_csdev_list;
  

};

/*

2.17.1