drivers/hwtracing/coresight/coresight-syscfg-configfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2020 Linaro Limited, All rights reserved.
   4  * Author: Mike Leach <mike.leach@linaro.org>
   5  */
   6
   7 #include <linux/configfs.h>
   8
   9 #include "coresight-config.h"
  10 #include "coresight-syscfg-configfs.h"
  11
  12 /* create a default ci_type. */
  13 static inline struct config_item_type *cscfg_create_ci_type(void)
  14 {
  15         struct config_item_type *ci_type;
  16
  17         ci_type = devm_kzalloc(cscfg_device(), sizeof(*ci_type), GFP_KERNEL);
  18         if (ci_type)
  19                 ci_type->ct_owner = THIS_MODULE;
  20
  21         return ci_type;
  22 }
  23
  24 /* configurations sub-group */
  25
  26 /* attributes for the config view group */
  27 static ssize_t cscfg_cfg_description_show(struct config_item *item, char *page)
  28 {
  29         struct cscfg_fs_config *fs_config = container_of(to_config_group(item),
  30                                                          struct cscfg_fs_config, group);
  31
  32         return scnprintf(page, PAGE_SIZE, "%s", fs_config->config_desc->description);
  33 }
  34 CONFIGFS_ATTR_RO(cscfg_cfg_, description);
  35
  36 static ssize_t cscfg_cfg_feature_refs_show(struct config_item *item, char *page)
  37 {
  38         struct cscfg_fs_config *fs_config = container_of(to_config_group(item),
  39                                                          struct cscfg_fs_config, group);
  40         const struct cscfg_config_desc *config_desc = fs_config->config_desc;
  41         ssize_t ch_used = 0;
  42         int i;
  43
  44         for (i = 0; i < config_desc->nr_feat_refs; i++)
  45                 ch_used += scnprintf(page + ch_used, PAGE_SIZE - ch_used,
  46                                      "%s\n", config_desc->feat_ref_names[i]);
  47         return ch_used;
  48 }
  49 CONFIGFS_ATTR_RO(cscfg_cfg_, feature_refs);
  50
  51 /* list preset values in order of features and params */
  52 static ssize_t cscfg_cfg_values_show(struct config_item *item, char *page)
  53 {
  54         const struct cscfg_feature_desc *feat_desc;
  55         const struct cscfg_config_desc *config_desc;
  56         struct cscfg_fs_preset *fs_preset;
  57         int i, j, val_idx, preset_idx;
  58         ssize_t used = 0;
  59
  60         fs_preset = container_of(to_config_group(item), struct cscfg_fs_preset, group);
  61         config_desc = fs_preset->config_desc;
  62
  63         if (!config_desc->nr_presets)
  64                 return 0;
  65
  66         preset_idx = fs_preset->preset_num - 1;
  67
  68         /* start index on the correct array line */
  69         val_idx = config_desc->nr_total_params * preset_idx;
  70
  71         /*
  72          * A set of presets is the sum of all params in used features,
  73          * in order of declaration of features and params in the features
  74          */
  75         for (i = 0; i < config_desc->nr_feat_refs; i++) {
  76                 feat_desc = cscfg_get_named_feat_desc(config_desc->feat_ref_names[i]);
  77                 for (j = 0; j < feat_desc->nr_params; j++) {
  78                         used += scnprintf(page + used, PAGE_SIZE - used,
  79                                           "%s.%s = 0x%llx ",
  80                                           feat_desc->name,
  81                                           feat_desc->params_desc[j].name,
  82                                           config_desc->presets[val_idx++]);
  83                 }
  84         }
  85         used += scnprintf(page + used, PAGE_SIZE - used, "\n");
  86
  87         return used;
  88 }
  89 CONFIGFS_ATTR_RO(cscfg_cfg_, values);
  90
  91 static ssize_t cscfg_cfg_enable_show(struct config_item *item, char *page)
  92 {
  93         struct cscfg_fs_config *fs_config = container_of(to_config_group(item),
  94                                                          struct cscfg_fs_config, group);
  95
  96         return scnprintf(page, PAGE_SIZE, "%d\n", fs_config->active);
  97 }
  98
  99 static ssize_t cscfg_cfg_enable_store(struct config_item *item,
 100                                         const char *page, size_t count)
 101 {
 102         struct cscfg_fs_config *fs_config = container_of(to_config_group(item),
 103                                                          struct cscfg_fs_config, group);
 104         int err;
 105         bool val;
 106
 107         err = kstrtobool(page, &val);
 108         if (!err)
 109                 err = cscfg_config_sysfs_activate(fs_config->config_desc, val);
 110         if (!err) {
 111                 fs_config->active = val;
 112                 if (val)
 113                         cscfg_config_sysfs_set_preset(fs_config->preset);
 114         }
 115         return err ? err : count;
 116 }
 117 CONFIGFS_ATTR(cscfg_cfg_, enable);
 118
 119 static ssize_t cscfg_cfg_preset_show(struct config_item *item, char *page)
 120 {
 121         struct cscfg_fs_config *fs_config = container_of(to_config_group(item),
 122                                                          struct cscfg_fs_config, group);
 123
 124         return scnprintf(page, PAGE_SIZE, "%d\n", fs_config->preset);
 125 }
 126
 127 static ssize_t cscfg_cfg_preset_store(struct config_item *item,
 128                                              const char *page, size_t count)
 129 {
 130         struct cscfg_fs_config *fs_config = container_of(to_config_group(item),
 131                                                          struct cscfg_fs_config, group);
 132         int preset, err;
 133
 134         err = kstrtoint(page, 0, &preset);
 135         if (!err) {
 136                 /*
 137                  * presets start at 1, and go up to max (15),
 138                  * but the config may provide fewer.
 139                  */
 140                 if ((preset < 1) || (preset > fs_config->config_desc->nr_presets))
 141                         err = -EINVAL;
 142         }
 143
 144         if (!err) {
 145                 /* set new value */
 146                 fs_config->preset = preset;
 147                 /* set on system if active */
 148                 if (fs_config->active)
 149                         cscfg_config_sysfs_set_preset(fs_config->preset);
 150         }
 151         return err ? err : count;
 152 }
 153 CONFIGFS_ATTR(cscfg_cfg_, preset);
 154
 155 static struct configfs_attribute *cscfg_config_view_attrs[] = {
 156         &cscfg_cfg_attr_description,
 157         &cscfg_cfg_attr_feature_refs,
 158         &cscfg_cfg_attr_enable,
 159         &cscfg_cfg_attr_preset,
 160         NULL,
 161 };
 162
 163 static struct config_item_type cscfg_config_view_type = {
 164         .ct_owner = THIS_MODULE,
 165         .ct_attrs = cscfg_config_view_attrs,
 166 };
 167
 168 static struct configfs_attribute *cscfg_config_preset_attrs[] = {
 169         &cscfg_cfg_attr_values,
 170         NULL,
 171 };
 172
 173 static struct config_item_type cscfg_config_preset_type = {
 174         .ct_owner = THIS_MODULE,
 175         .ct_attrs = cscfg_config_preset_attrs,
 176 };
 177
 178 static int cscfg_add_preset_groups(struct cscfg_fs_config *cfg_view)
 179 {
 180         int preset_num;
 181         struct cscfg_fs_preset *cfg_fs_preset;
 182         struct cscfg_config_desc *config_desc = cfg_view->config_desc;
 183         char name[CONFIGFS_ITEM_NAME_LEN];
 184
 185         if (!config_desc->nr_presets)
 186                 return 0;
 187
 188         for (preset_num = 1; preset_num <= config_desc->nr_presets; preset_num++) {
 189                 cfg_fs_preset = devm_kzalloc(cscfg_device(),
 190                                              sizeof(struct cscfg_fs_preset), GFP_KERNEL);
 191
 192                 if (!cfg_fs_preset)
 193                         return -ENOMEM;
 194
 195                 snprintf(name, CONFIGFS_ITEM_NAME_LEN, "preset%d", preset_num);
 196                 cfg_fs_preset->preset_num = preset_num;
 197                 cfg_fs_preset->config_desc = cfg_view->config_desc;
 198                 config_group_init_type_name(&cfg_fs_preset->group, name,
 199                                             &cscfg_config_preset_type);
 200                 configfs_add_default_group(&cfg_fs_preset->group, &cfg_view->group);
 201         }
 202         return 0;
 203 }
 204
 205 static struct config_group *cscfg_create_config_group(struct cscfg_config_desc *config_desc)
 206 {
 207         struct cscfg_fs_config *cfg_view;
 208         struct device *dev = cscfg_device();
 209         int err;
 210
 211         if (!dev)
 212                 return ERR_PTR(-EINVAL);
 213
 214         cfg_view = devm_kzalloc(dev, sizeof(struct cscfg_fs_config), GFP_KERNEL);
 215         if (!cfg_view)
 216                 return ERR_PTR(-ENOMEM);
 217
 218         cfg_view->config_desc = config_desc;
 219         config_group_init_type_name(&cfg_view->group, config_desc->name, &cscfg_config_view_type);
 220
 221         /* add in a preset<n> dir for each preset */
 222         err = cscfg_add_preset_groups(cfg_view);
 223         if (err)
 224                 return ERR_PTR(err);
 225
 226         return &cfg_view->group;
 227 }
 228
 229 /* attributes for features view */
 230
 231 static ssize_t cscfg_feat_description_show(struct config_item *item, char *page)
 232 {
 233         struct cscfg_fs_feature *fs_feat = container_of(to_config_group(item),
 234                                                         struct cscfg_fs_feature, group);
 235
 236         return scnprintf(page, PAGE_SIZE, "%s", fs_feat->feat_desc->description);
 237 }
 238 CONFIGFS_ATTR_RO(cscfg_feat_, description);
 239
 240 static ssize_t cscfg_feat_matches_show(struct config_item *item, char *page)
 241 {
 242         struct cscfg_fs_feature *fs_feat = container_of(to_config_group(item),
 243                                                         struct cscfg_fs_feature, group);
 244         u32 match_flags = fs_feat->feat_desc->match_flags;
 245         int used = 0;
 246
 247         if (match_flags & CS_CFG_MATCH_CLASS_SRC_ALL)
 248                 used = scnprintf(page, PAGE_SIZE, "SRC_ALL ");
 249
 250         if (match_flags & CS_CFG_MATCH_CLASS_SRC_ETM4)
 251                 used += scnprintf(page + used, PAGE_SIZE - used, "SRC_ETMV4 ");
 252
 253         used += scnprintf(page + used, PAGE_SIZE - used, "\n");
 254         return used;
 255 }
 256 CONFIGFS_ATTR_RO(cscfg_feat_, matches);
 257
 258 static ssize_t cscfg_feat_nr_params_show(struct config_item *item, char *page)
 259 {
 260         struct cscfg_fs_feature *fs_feat = container_of(to_config_group(item),
 261                                                         struct cscfg_fs_feature, group);
 262
 263         return scnprintf(page, PAGE_SIZE, "%d\n", fs_feat->feat_desc->nr_params);
 264 }
 265 CONFIGFS_ATTR_RO(cscfg_feat_, nr_params);
 266
 267 /* base feature desc attrib structures */
 268 static struct configfs_attribute *cscfg_feature_view_attrs[] = {
 269         &cscfg_feat_attr_description,
 270         &cscfg_feat_attr_matches,
 271         &cscfg_feat_attr_nr_params,
 272         NULL,
 273 };
 274
 275 static struct config_item_type cscfg_feature_view_type = {
 276         .ct_owner = THIS_MODULE,
 277         .ct_attrs = cscfg_feature_view_attrs,
 278 };
 279
 280 static ssize_t cscfg_param_value_show(struct config_item *item, char *page)
 281 {
 282         struct cscfg_fs_param *param_item = container_of(to_config_group(item),
 283                                                          struct cscfg_fs_param, group);
 284         u64 value = param_item->feat_desc->params_desc[param_item->param_idx].value;
 285
 286         return scnprintf(page, PAGE_SIZE, "0x%llx\n", value);
 287 }
 288
 289 static ssize_t cscfg_param_value_store(struct config_item *item,
 290                                        const char *page, size_t size)
 291 {
 292         struct cscfg_fs_param *param_item = container_of(to_config_group(item),
 293                                                          struct cscfg_fs_param, group);
 294         struct cscfg_feature_desc *feat_desc = param_item->feat_desc;
 295         int param_idx = param_item->param_idx;
 296         u64 value;
 297         int err;
 298
 299         err = kstrtoull(page, 0, &value);
 300         if (!err)
 301                 err = cscfg_update_feat_param_val(feat_desc, param_idx, value);
 302
 303         return err ? err : size;
 304 }
 305 CONFIGFS_ATTR(cscfg_param_, value);
 306
 307 static struct configfs_attribute *cscfg_param_view_attrs[] = {
 308         &cscfg_param_attr_value,
 309         NULL,
 310 };
 311
 312 static struct config_item_type cscfg_param_view_type = {
 313         .ct_owner = THIS_MODULE,
 314         .ct_attrs = cscfg_param_view_attrs,
 315 };
 316
 317 /*
 318  * configfs has far less functionality provided to add attributes dynamically than sysfs,
 319  * and the show and store fns pass the enclosing config_item so the actual attribute cannot
 320  * be determined. Therefore we add each item as a group directory, with a value attribute.
 321  */
 322 static int cscfg_create_params_group_items(struct cscfg_feature_desc *feat_desc,
 323                                            struct config_group *params_group)
 324 {
 325         struct device *dev = cscfg_device();
 326         struct cscfg_fs_param *param_item;
 327         int i;
 328
 329         /* parameter items - as groups with default_value attribute */
 330         for (i = 0; i < feat_desc->nr_params; i++) {
 331                 param_item = devm_kzalloc(dev, sizeof(struct cscfg_fs_param), GFP_KERNEL);
 332                 if (!param_item)
 333                         return -ENOMEM;
 334                 param_item->feat_desc = feat_desc;
 335                 param_item->param_idx = i;
 336                 config_group_init_type_name(&param_item->group,
 337                                             feat_desc->params_desc[i].name,
 338                                             &cscfg_param_view_type);
 339                 configfs_add_default_group(&param_item->group, params_group);
 340         }
 341         return 0;
 342 }
 343
 344 static struct config_group *cscfg_create_feature_group(struct cscfg_feature_desc *feat_desc)
 345 {
 346         struct cscfg_fs_feature *feat_view;
 347         struct config_item_type *params_group_type;
 348         struct config_group *params_group = NULL;
 349         struct device *dev = cscfg_device();
 350         int item_err;
 351
 352         if (!dev)
 353                 return ERR_PTR(-EINVAL);
 354
 355         feat_view = devm_kzalloc(dev, sizeof(struct cscfg_fs_feature), GFP_KERNEL);
 356         if (!feat_view)
 357                 return ERR_PTR(-ENOMEM);
 358
 359         if (feat_desc->nr_params) {
 360                 params_group = devm_kzalloc(dev, sizeof(struct config_group), GFP_KERNEL);
 361                 if (!params_group)
 362                         return ERR_PTR(-ENOMEM);
 363
 364                 params_group_type = cscfg_create_ci_type();
 365                 if (!params_group_type)
 366                         return ERR_PTR(-ENOMEM);
 367         }
 368
 369         feat_view->feat_desc = feat_desc;
 370         config_group_init_type_name(&feat_view->group,
 371                                     feat_desc->name,
 372                                     &cscfg_feature_view_type);
 373         if (params_group) {
 374                 config_group_init_type_name(params_group, "params", params_group_type);
 375                 configfs_add_default_group(params_group, &feat_view->group);
 376                 item_err = cscfg_create_params_group_items(feat_desc, params_group);
 377                 if (item_err)
 378                         return ERR_PTR(item_err);
 379         }
 380         return &feat_view->group;
 381 }
 382
 383 static struct config_item_type cscfg_configs_type = {
 384         .ct_owner = THIS_MODULE,
 385 };
 386
 387 static struct config_group cscfg_configs_grp = {
 388         .cg_item = {
 389                 .ci_namebuf = "configurations",
 390                 .ci_type = &cscfg_configs_type,
 391         },
 392 };
 393
 394 /* add configuration to configurations group */
 395 int cscfg_configfs_add_config(struct cscfg_config_desc *config_desc)
 396 {
 397         struct config_group *new_group;
 398         int err;
 399
 400         new_group = cscfg_create_config_group(config_desc);
 401         if (IS_ERR(new_group))
 402                 return PTR_ERR(new_group);
 403         err =  configfs_register_group(&cscfg_configs_grp, new_group);
 404         if (!err)
 405                 config_desc->fs_group = new_group;
 406         return err;
 407 }
 408
 409 void cscfg_configfs_del_config(struct cscfg_config_desc *config_desc)
 410 {
 411         if (config_desc->fs_group) {
 412                 configfs_unregister_group(config_desc->fs_group);
 413                 config_desc->fs_group = NULL;
 414         }
 415 }
 416
 417 static struct config_item_type cscfg_features_type = {
 418         .ct_owner = THIS_MODULE,
 419 };
 420
 421 static struct config_group cscfg_features_grp = {
 422         .cg_item = {
 423                 .ci_namebuf = "features",
 424                 .ci_type = &cscfg_features_type,
 425         },
 426 };
 427
 428 /* add feature to features group */
 429 int cscfg_configfs_add_feature(struct cscfg_feature_desc *feat_desc)
 430 {
 431         struct config_group *new_group;
 432         int err;
 433
 434         new_group = cscfg_create_feature_group(feat_desc);
 435         if (IS_ERR(new_group))
 436                 return PTR_ERR(new_group);
 437         err =  configfs_register_group(&cscfg_features_grp, new_group);
 438         if (!err)
 439                 feat_desc->fs_group = new_group;
 440         return err;
 441 }
 442
 443 void cscfg_configfs_del_feature(struct cscfg_feature_desc *feat_desc)
 444 {
 445         if (feat_desc->fs_group) {
 446                 configfs_unregister_group(feat_desc->fs_group);
 447                 feat_desc->fs_group = NULL;
 448         }
 449 }
 450
 451 int cscfg_configfs_init(struct cscfg_manager *cscfg_mgr)
 452 {
 453         struct configfs_subsystem *subsys;
 454         struct config_item_type *ci_type;
 455
 456         if (!cscfg_mgr)
 457                 return -EINVAL;
 458
 459         ci_type = cscfg_create_ci_type();
 460         if (!ci_type)
 461                 return -ENOMEM;
 462
 463         subsys = &cscfg_mgr->cfgfs_subsys;
 464         config_item_set_name(&subsys->su_group.cg_item, CSCFG_FS_SUBSYS_NAME);
 465         subsys->su_group.cg_item.ci_type = ci_type;
 466
 467         config_group_init(&subsys->su_group);
 468         mutex_init(&subsys->su_mutex);
 469
 470         /* Add default groups to subsystem */
 471         config_group_init(&cscfg_configs_grp);
 472         configfs_add_default_group(&cscfg_configs_grp, &subsys->su_group);
 473
 474         config_group_init(&cscfg_features_grp);
 475         configfs_add_default_group(&cscfg_features_grp, &subsys->su_group);
 476
 477         return configfs_register_subsystem(subsys);
 478 }
 479
 480 void cscfg_configfs_release(struct cscfg_manager *cscfg_mgr)
 481 {
 482         configfs_unregister_subsystem(&cscfg_mgr->cfgfs_subsys);
 483 }