Loading...
Note: File does not exist in v5.4.
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/platform_device.h>
8#include <linux/slab.h>
9
10#include "coresight-config.h"
11#include "coresight-etm-perf.h"
12#include "coresight-syscfg.h"
13#include "coresight-syscfg-configfs.h"
14
15/*
16 * cscfg_ API manages configurations and features for the entire coresight
17 * infrastructure.
18 *
19 * It allows the loading of configurations and features, and loads these into
20 * coresight devices as appropriate.
21 */
22
23/* protect the cscsg_data and device */
24static DEFINE_MUTEX(cscfg_mutex);
25
26/* only one of these */
27static struct cscfg_manager *cscfg_mgr;
28
29/* load features and configuations into the lists */
30
31/* get name feature instance from a coresight device list of features */
32static struct cscfg_feature_csdev *
33cscfg_get_feat_csdev(struct coresight_device *csdev, const char *name)
34{
35 struct cscfg_feature_csdev *feat_csdev = NULL;
36
37 list_for_each_entry(feat_csdev, &csdev->feature_csdev_list, node) {
38 if (strcmp(feat_csdev->feat_desc->name, name) == 0)
39 return feat_csdev;
40 }
41 return NULL;
42}
43
44/* allocate the device config instance - with max number of used features */
45static struct cscfg_config_csdev *
46cscfg_alloc_csdev_cfg(struct coresight_device *csdev, int nr_feats)
47{
48 struct cscfg_config_csdev *config_csdev = NULL;
49 struct device *dev = csdev->dev.parent;
50
51 /* this is being allocated using the devm for the coresight device */
52 config_csdev = devm_kzalloc(dev,
53 offsetof(struct cscfg_config_csdev, feats_csdev[nr_feats]),
54 GFP_KERNEL);
55 if (!config_csdev)
56 return NULL;
57
58 config_csdev->csdev = csdev;
59 return config_csdev;
60}
61
62/* Load a config into a device if there are any feature matches between config and device */
63static int cscfg_add_csdev_cfg(struct coresight_device *csdev,
64 struct cscfg_config_desc *config_desc)
65{
66 struct cscfg_config_csdev *config_csdev = NULL;
67 struct cscfg_feature_csdev *feat_csdev;
68 unsigned long flags;
69 int i;
70
71 /* look at each required feature and see if it matches any feature on the device */
72 for (i = 0; i < config_desc->nr_feat_refs; i++) {
73 /* look for a matching name */
74 feat_csdev = cscfg_get_feat_csdev(csdev, config_desc->feat_ref_names[i]);
75 if (feat_csdev) {
76 /*
77 * At least one feature on this device matches the config
78 * add a config instance to the device and a reference to the feature.
79 */
80 if (!config_csdev) {
81 config_csdev = cscfg_alloc_csdev_cfg(csdev,
82 config_desc->nr_feat_refs);
83 if (!config_csdev)
84 return -ENOMEM;
85 config_csdev->config_desc = config_desc;
86 }
87 config_csdev->feats_csdev[config_csdev->nr_feat++] = feat_csdev;
88 }
89 }
90 /* if matched features, add config to device.*/
91 if (config_csdev) {
92 spin_lock_irqsave(&csdev->cscfg_csdev_lock, flags);
93 list_add(&config_csdev->node, &csdev->config_csdev_list);
94 spin_unlock_irqrestore(&csdev->cscfg_csdev_lock, flags);
95 }
96
97 return 0;
98}
99
100/*
101 * Add the config to the set of registered devices - call with mutex locked.
102 * Iterates through devices - any device that matches one or more of the
103 * configuration features will load it, the others will ignore it.
104 */
105static int cscfg_add_cfg_to_csdevs(struct cscfg_config_desc *config_desc)
106{
107 struct cscfg_registered_csdev *csdev_item;
108 int err;
109
110 list_for_each_entry(csdev_item, &cscfg_mgr->csdev_desc_list, item) {
111 err = cscfg_add_csdev_cfg(csdev_item->csdev, config_desc);
112 if (err)
113 return err;
114 }
115 return 0;
116}
117
118/*
119 * Allocate a feature object for load into a csdev.
120 * memory allocated using the csdev->dev object using devm managed allocator.
121 */
122static struct cscfg_feature_csdev *
123cscfg_alloc_csdev_feat(struct coresight_device *csdev, struct cscfg_feature_desc *feat_desc)
124{
125 struct cscfg_feature_csdev *feat_csdev = NULL;
126 struct device *dev = csdev->dev.parent;
127 int i;
128
129 feat_csdev = devm_kzalloc(dev, sizeof(struct cscfg_feature_csdev), GFP_KERNEL);
130 if (!feat_csdev)
131 return NULL;
132
133 /* parameters are optional - could be 0 */
134 feat_csdev->nr_params = feat_desc->nr_params;
135
136 /*
137 * if we need parameters, zero alloc the space here, the load routine in
138 * the csdev device driver will fill out some information according to
139 * feature descriptor.
140 */
141 if (feat_csdev->nr_params) {
142 feat_csdev->params_csdev = devm_kcalloc(dev, feat_csdev->nr_params,
143 sizeof(struct cscfg_parameter_csdev),
144 GFP_KERNEL);
145 if (!feat_csdev->params_csdev)
146 return NULL;
147
148 /*
149 * fill in the feature reference in the param - other fields
150 * handled by loader in csdev.
151 */
152 for (i = 0; i < feat_csdev->nr_params; i++)
153 feat_csdev->params_csdev[i].feat_csdev = feat_csdev;
154 }
155
156 /*
157 * Always have registers to program - again the load routine in csdev device
158 * will fill out according to feature descriptor and device requirements.
159 */
160 feat_csdev->nr_regs = feat_desc->nr_regs;
161 feat_csdev->regs_csdev = devm_kcalloc(dev, feat_csdev->nr_regs,
162 sizeof(struct cscfg_regval_csdev),
163 GFP_KERNEL);
164 if (!feat_csdev->regs_csdev)
165 return NULL;
166
167 /* load the feature default values */
168 feat_csdev->feat_desc = feat_desc;
169 feat_csdev->csdev = csdev;
170
171 return feat_csdev;
172}
173
174/* load one feature into one coresight device */
175static int cscfg_load_feat_csdev(struct coresight_device *csdev,
176 struct cscfg_feature_desc *feat_desc,
177 struct cscfg_csdev_feat_ops *ops)
178{
179 struct cscfg_feature_csdev *feat_csdev;
180 unsigned long flags;
181 int err;
182
183 if (!ops->load_feat)
184 return -EINVAL;
185
186 feat_csdev = cscfg_alloc_csdev_feat(csdev, feat_desc);
187 if (!feat_csdev)
188 return -ENOMEM;
189
190 /* load the feature into the device */
191 err = ops->load_feat(csdev, feat_csdev);
192 if (err)
193 return err;
194
195 /* add to internal csdev feature list & initialise using reset call */
196 cscfg_reset_feat(feat_csdev);
197 spin_lock_irqsave(&csdev->cscfg_csdev_lock, flags);
198 list_add(&feat_csdev->node, &csdev->feature_csdev_list);
199 spin_unlock_irqrestore(&csdev->cscfg_csdev_lock, flags);
200
201 return 0;
202}
203
204/*
205 * Add feature to any matching devices - call with mutex locked.
206 * Iterates through devices - any device that matches the feature will be
207 * called to load it.
208 */
209static int cscfg_add_feat_to_csdevs(struct cscfg_feature_desc *feat_desc)
210{
211 struct cscfg_registered_csdev *csdev_item;
212 int err;
213
214 list_for_each_entry(csdev_item, &cscfg_mgr->csdev_desc_list, item) {
215 if (csdev_item->match_flags & feat_desc->match_flags) {
216 err = cscfg_load_feat_csdev(csdev_item->csdev, feat_desc, &csdev_item->ops);
217 if (err)
218 return err;
219 }
220 }
221 return 0;
222}
223
224/* check feature list for a named feature - call with mutex locked. */
225static bool cscfg_match_list_feat(const char *name)
226{
227 struct cscfg_feature_desc *feat_desc;
228
229 list_for_each_entry(feat_desc, &cscfg_mgr->feat_desc_list, item) {
230 if (strcmp(feat_desc->name, name) == 0)
231 return true;
232 }
233 return false;
234}
235
236/* check all feat needed for cfg are in the list - call with mutex locked. */
237static int cscfg_check_feat_for_cfg(struct cscfg_config_desc *config_desc)
238{
239 int i;
240
241 for (i = 0; i < config_desc->nr_feat_refs; i++)
242 if (!cscfg_match_list_feat(config_desc->feat_ref_names[i]))
243 return -EINVAL;
244 return 0;
245}
246
247/*
248 * load feature - add to feature list.
249 */
250static int cscfg_load_feat(struct cscfg_feature_desc *feat_desc)
251{
252 int err;
253 struct cscfg_feature_desc *feat_desc_exist;
254
255 /* new feature must have unique name */
256 list_for_each_entry(feat_desc_exist, &cscfg_mgr->feat_desc_list, item) {
257 if (!strcmp(feat_desc_exist->name, feat_desc->name))
258 return -EEXIST;
259 }
260
261 /* add feature to any matching registered devices */
262 err = cscfg_add_feat_to_csdevs(feat_desc);
263 if (err)
264 return err;
265
266 list_add(&feat_desc->item, &cscfg_mgr->feat_desc_list);
267 return 0;
268}
269
270/*
271 * load config into the system - validate used features exist then add to
272 * config list.
273 */
274static int cscfg_load_config(struct cscfg_config_desc *config_desc)
275{
276 int err;
277 struct cscfg_config_desc *config_desc_exist;
278
279 /* new configuration must have a unique name */
280 list_for_each_entry(config_desc_exist, &cscfg_mgr->config_desc_list, item) {
281 if (!strcmp(config_desc_exist->name, config_desc->name))
282 return -EEXIST;
283 }
284
285 /* validate features are present */
286 err = cscfg_check_feat_for_cfg(config_desc);
287 if (err)
288 return err;
289
290 /* add config to any matching registered device */
291 err = cscfg_add_cfg_to_csdevs(config_desc);
292 if (err)
293 return err;
294
295 /* add config to perf fs to allow selection */
296 err = etm_perf_add_symlink_cscfg(cscfg_device(), config_desc);
297 if (err)
298 return err;
299
300 list_add(&config_desc->item, &cscfg_mgr->config_desc_list);
301 atomic_set(&config_desc->active_cnt, 0);
302 return 0;
303}
304
305/* get a feature descriptor by name */
306const struct cscfg_feature_desc *cscfg_get_named_feat_desc(const char *name)
307{
308 const struct cscfg_feature_desc *feat_desc = NULL, *feat_desc_item;
309
310 mutex_lock(&cscfg_mutex);
311
312 list_for_each_entry(feat_desc_item, &cscfg_mgr->feat_desc_list, item) {
313 if (strcmp(feat_desc_item->name, name) == 0) {
314 feat_desc = feat_desc_item;
315 break;
316 }
317 }
318
319 mutex_unlock(&cscfg_mutex);
320 return feat_desc;
321}
322
323/* called with cscfg_mutex held */
324static struct cscfg_feature_csdev *
325cscfg_csdev_get_feat_from_desc(struct coresight_device *csdev,
326 struct cscfg_feature_desc *feat_desc)
327{
328 struct cscfg_feature_csdev *feat_csdev;
329
330 list_for_each_entry(feat_csdev, &csdev->feature_csdev_list, node) {
331 if (feat_csdev->feat_desc == feat_desc)
332 return feat_csdev;
333 }
334 return NULL;
335}
336
337int cscfg_update_feat_param_val(struct cscfg_feature_desc *feat_desc,
338 int param_idx, u64 value)
339{
340 int err = 0;
341 struct cscfg_feature_csdev *feat_csdev;
342 struct cscfg_registered_csdev *csdev_item;
343
344 mutex_lock(&cscfg_mutex);
345
346 /* check if any config active & return busy */
347 if (atomic_read(&cscfg_mgr->sys_active_cnt)) {
348 err = -EBUSY;
349 goto unlock_exit;
350 }
351
352 /* set the value */
353 if ((param_idx < 0) || (param_idx >= feat_desc->nr_params)) {
354 err = -EINVAL;
355 goto unlock_exit;
356 }
357 feat_desc->params_desc[param_idx].value = value;
358
359 /* update loaded instances.*/
360 list_for_each_entry(csdev_item, &cscfg_mgr->csdev_desc_list, item) {
361 feat_csdev = cscfg_csdev_get_feat_from_desc(csdev_item->csdev, feat_desc);
362 if (feat_csdev)
363 feat_csdev->params_csdev[param_idx].current_value = value;
364 }
365
366unlock_exit:
367 mutex_unlock(&cscfg_mutex);
368 return err;
369}
370
371/*
372 * Conditionally up reference count on owner to prevent unload.
373 *
374 * module loaded configs need to be locked in to prevent premature unload.
375 */
376static int cscfg_owner_get(struct cscfg_load_owner_info *owner_info)
377{
378 if ((owner_info->type == CSCFG_OWNER_MODULE) &&
379 (!try_module_get(owner_info->owner_handle)))
380 return -EINVAL;
381 return 0;
382}
383
384/* conditionally lower ref count on an owner */
385static void cscfg_owner_put(struct cscfg_load_owner_info *owner_info)
386{
387 if (owner_info->type == CSCFG_OWNER_MODULE)
388 module_put(owner_info->owner_handle);
389}
390
391static void cscfg_remove_owned_csdev_configs(struct coresight_device *csdev, void *load_owner)
392{
393 struct cscfg_config_csdev *config_csdev, *tmp;
394
395 if (list_empty(&csdev->config_csdev_list))
396 return;
397
398 list_for_each_entry_safe(config_csdev, tmp, &csdev->config_csdev_list, node) {
399 if (config_csdev->config_desc->load_owner == load_owner)
400 list_del(&config_csdev->node);
401 }
402}
403
404static void cscfg_remove_owned_csdev_features(struct coresight_device *csdev, void *load_owner)
405{
406 struct cscfg_feature_csdev *feat_csdev, *tmp;
407
408 if (list_empty(&csdev->feature_csdev_list))
409 return;
410
411 list_for_each_entry_safe(feat_csdev, tmp, &csdev->feature_csdev_list, node) {
412 if (feat_csdev->feat_desc->load_owner == load_owner)
413 list_del(&feat_csdev->node);
414 }
415}
416
417/*
418 * Unregister all configuration and features from configfs owned by load_owner.
419 * Although this is called without the list mutex being held, it is in the
420 * context of an unload operation which are strictly serialised,
421 * so the lists cannot change during this call.
422 */
423static void cscfg_fs_unregister_cfgs_feats(void *load_owner)
424{
425 struct cscfg_config_desc *config_desc;
426 struct cscfg_feature_desc *feat_desc;
427
428 list_for_each_entry(config_desc, &cscfg_mgr->config_desc_list, item) {
429 if (config_desc->load_owner == load_owner)
430 cscfg_configfs_del_config(config_desc);
431 }
432 list_for_each_entry(feat_desc, &cscfg_mgr->feat_desc_list, item) {
433 if (feat_desc->load_owner == load_owner)
434 cscfg_configfs_del_feature(feat_desc);
435 }
436}
437
438/*
439 * removal is relatively easy - just remove from all lists, anything that
440 * matches the owner. Memory for the descriptors will be managed by the owner,
441 * memory for the csdev items is devm_ allocated with the individual csdev
442 * devices.
443 */
444static void cscfg_unload_owned_cfgs_feats(void *load_owner)
445{
446 struct cscfg_config_desc *config_desc, *cfg_tmp;
447 struct cscfg_feature_desc *feat_desc, *feat_tmp;
448 struct cscfg_registered_csdev *csdev_item;
449
450 lockdep_assert_held(&cscfg_mutex);
451
452 /* remove from each csdev instance feature and config lists */
453 list_for_each_entry(csdev_item, &cscfg_mgr->csdev_desc_list, item) {
454 /*
455 * for each csdev, check the loaded lists and remove if
456 * referenced descriptor is owned
457 */
458 cscfg_remove_owned_csdev_configs(csdev_item->csdev, load_owner);
459 cscfg_remove_owned_csdev_features(csdev_item->csdev, load_owner);
460 }
461
462 /* remove from the config descriptor lists */
463 list_for_each_entry_safe(config_desc, cfg_tmp, &cscfg_mgr->config_desc_list, item) {
464 if (config_desc->load_owner == load_owner) {
465 etm_perf_del_symlink_cscfg(config_desc);
466 list_del(&config_desc->item);
467 }
468 }
469
470 /* remove from the feature descriptor lists */
471 list_for_each_entry_safe(feat_desc, feat_tmp, &cscfg_mgr->feat_desc_list, item) {
472 if (feat_desc->load_owner == load_owner) {
473 list_del(&feat_desc->item);
474 }
475 }
476}
477
478/*
479 * load the features and configs to the lists - called with list mutex held
480 */
481static int cscfg_load_owned_cfgs_feats(struct cscfg_config_desc **config_descs,
482 struct cscfg_feature_desc **feat_descs,
483 struct cscfg_load_owner_info *owner_info)
484{
485 int i, err;
486
487 lockdep_assert_held(&cscfg_mutex);
488
489 /* load features first */
490 if (feat_descs) {
491 for (i = 0; feat_descs[i]; i++) {
492 err = cscfg_load_feat(feat_descs[i]);
493 if (err) {
494 pr_err("coresight-syscfg: Failed to load feature %s\n",
495 feat_descs[i]->name);
496 return err;
497 }
498 feat_descs[i]->load_owner = owner_info;
499 }
500 }
501
502 /* next any configurations to check feature dependencies */
503 if (config_descs) {
504 for (i = 0; config_descs[i]; i++) {
505 err = cscfg_load_config(config_descs[i]);
506 if (err) {
507 pr_err("coresight-syscfg: Failed to load configuration %s\n",
508 config_descs[i]->name);
509 return err;
510 }
511 config_descs[i]->load_owner = owner_info;
512 config_descs[i]->available = false;
513 }
514 }
515 return 0;
516}
517
518/* set configurations as available to activate at the end of the load process */
519static void cscfg_set_configs_available(struct cscfg_config_desc **config_descs)
520{
521 int i;
522
523 lockdep_assert_held(&cscfg_mutex);
524
525 if (config_descs) {
526 for (i = 0; config_descs[i]; i++)
527 config_descs[i]->available = true;
528 }
529}
530
531/*
532 * Create and register each of the configurations and features with configfs.
533 * Called without mutex being held.
534 */
535static int cscfg_fs_register_cfgs_feats(struct cscfg_config_desc **config_descs,
536 struct cscfg_feature_desc **feat_descs)
537{
538 int i, err;
539
540 if (feat_descs) {
541 for (i = 0; feat_descs[i]; i++) {
542 err = cscfg_configfs_add_feature(feat_descs[i]);
543 if (err)
544 return err;
545 }
546 }
547 if (config_descs) {
548 for (i = 0; config_descs[i]; i++) {
549 err = cscfg_configfs_add_config(config_descs[i]);
550 if (err)
551 return err;
552 }
553 }
554 return 0;
555}
556
557/**
558 * cscfg_load_config_sets - API function to load feature and config sets.
559 *
560 * Take a 0 terminated array of feature descriptors and/or configuration
561 * descriptors and load into the system.
562 * Features are loaded first to ensure configuration dependencies can be met.
563 *
564 * To facilitate dynamic loading and unloading, features and configurations
565 * have a "load_owner", to allow later unload by the same owner. An owner may
566 * be a loadable module or configuration dynamically created via configfs.
567 * As later loaded configurations can use earlier loaded features, creating load
568 * dependencies, a load order list is maintained. Unload is strictly in the
569 * reverse order to load.
570 *
571 * @config_descs: 0 terminated array of configuration descriptors.
572 * @feat_descs: 0 terminated array of feature descriptors.
573 * @owner_info: Information on the owner of this set.
574 */
575int cscfg_load_config_sets(struct cscfg_config_desc **config_descs,
576 struct cscfg_feature_desc **feat_descs,
577 struct cscfg_load_owner_info *owner_info)
578{
579 int err = 0;
580
581 mutex_lock(&cscfg_mutex);
582 if (cscfg_mgr->load_state != CSCFG_NONE) {
583 mutex_unlock(&cscfg_mutex);
584 return -EBUSY;
585 }
586 cscfg_mgr->load_state = CSCFG_LOAD;
587
588 /* first load and add to the lists */
589 err = cscfg_load_owned_cfgs_feats(config_descs, feat_descs, owner_info);
590 if (err)
591 goto err_clean_load;
592
593 /* add the load owner to the load order list */
594 list_add_tail(&owner_info->item, &cscfg_mgr->load_order_list);
595 if (!list_is_singular(&cscfg_mgr->load_order_list)) {
596 /* lock previous item in load order list */
597 err = cscfg_owner_get(list_prev_entry(owner_info, item));
598 if (err)
599 goto err_clean_owner_list;
600 }
601
602 /*
603 * make visible to configfs - configfs manipulation must occur outside
604 * the list mutex lock to avoid circular lockdep issues with configfs
605 * built in mutexes and semaphores. This is safe as it is not possible
606 * to start a new load/unload operation till the current one is done.
607 */
608 mutex_unlock(&cscfg_mutex);
609
610 /* create the configfs elements */
611 err = cscfg_fs_register_cfgs_feats(config_descs, feat_descs);
612 mutex_lock(&cscfg_mutex);
613
614 if (err)
615 goto err_clean_cfs;
616
617 /* mark any new configs as available for activation */
618 cscfg_set_configs_available(config_descs);
619 goto exit_unlock;
620
621err_clean_cfs:
622 /* cleanup after error registering with configfs */
623 cscfg_fs_unregister_cfgs_feats(owner_info);
624
625 if (!list_is_singular(&cscfg_mgr->load_order_list))
626 cscfg_owner_put(list_prev_entry(owner_info, item));
627
628err_clean_owner_list:
629 list_del(&owner_info->item);
630
631err_clean_load:
632 cscfg_unload_owned_cfgs_feats(owner_info);
633
634exit_unlock:
635 cscfg_mgr->load_state = CSCFG_NONE;
636 mutex_unlock(&cscfg_mutex);
637 return err;
638}
639EXPORT_SYMBOL_GPL(cscfg_load_config_sets);
640
641/**
642 * cscfg_unload_config_sets - unload a set of configurations by owner.
643 *
644 * Dynamic unload of configuration and feature sets is done on the basis of
645 * the load owner of that set. Later loaded configurations can depend on
646 * features loaded earlier.
647 *
648 * Therefore, unload is only possible if:-
649 * 1) no configurations are active.
650 * 2) the set being unloaded was the last to be loaded to maintain dependencies.
651 *
652 * Once the unload operation commences, we disallow any configuration being
653 * made active until it is complete.
654 *
655 * @owner_info: Information on owner for set being unloaded.
656 */
657int cscfg_unload_config_sets(struct cscfg_load_owner_info *owner_info)
658{
659 int err = 0;
660 struct cscfg_load_owner_info *load_list_item = NULL;
661
662 mutex_lock(&cscfg_mutex);
663 if (cscfg_mgr->load_state != CSCFG_NONE) {
664 mutex_unlock(&cscfg_mutex);
665 return -EBUSY;
666 }
667
668 /* unload op in progress also prevents activation of any config */
669 cscfg_mgr->load_state = CSCFG_UNLOAD;
670
671 /* cannot unload if anything is active */
672 if (atomic_read(&cscfg_mgr->sys_active_cnt)) {
673 err = -EBUSY;
674 goto exit_unlock;
675 }
676
677 /* cannot unload if not last loaded in load order */
678 if (!list_empty(&cscfg_mgr->load_order_list)) {
679 load_list_item = list_last_entry(&cscfg_mgr->load_order_list,
680 struct cscfg_load_owner_info, item);
681 if (load_list_item != owner_info)
682 load_list_item = NULL;
683 }
684
685 if (!load_list_item) {
686 err = -EINVAL;
687 goto exit_unlock;
688 }
689
690 /* remove from configfs - again outside the scope of the list mutex */
691 mutex_unlock(&cscfg_mutex);
692 cscfg_fs_unregister_cfgs_feats(owner_info);
693 mutex_lock(&cscfg_mutex);
694
695 /* unload everything from lists belonging to load_owner */
696 cscfg_unload_owned_cfgs_feats(owner_info);
697
698 /* remove from load order list */
699 if (!list_is_singular(&cscfg_mgr->load_order_list)) {
700 /* unlock previous item in load order list */
701 cscfg_owner_put(list_prev_entry(owner_info, item));
702 }
703 list_del(&owner_info->item);
704
705exit_unlock:
706 cscfg_mgr->load_state = CSCFG_NONE;
707 mutex_unlock(&cscfg_mutex);
708 return err;
709}
710EXPORT_SYMBOL_GPL(cscfg_unload_config_sets);
711
712/* Handle coresight device registration and add configs and features to devices */
713
714/* iterate through config lists and load matching configs to device */
715static int cscfg_add_cfgs_csdev(struct coresight_device *csdev)
716{
717 struct cscfg_config_desc *config_desc;
718 int err = 0;
719
720 list_for_each_entry(config_desc, &cscfg_mgr->config_desc_list, item) {
721 err = cscfg_add_csdev_cfg(csdev, config_desc);
722 if (err)
723 break;
724 }
725 return err;
726}
727
728/* iterate through feature lists and load matching features to device */
729static int cscfg_add_feats_csdev(struct coresight_device *csdev,
730 u32 match_flags,
731 struct cscfg_csdev_feat_ops *ops)
732{
733 struct cscfg_feature_desc *feat_desc;
734 int err = 0;
735
736 if (!ops->load_feat)
737 return -EINVAL;
738
739 list_for_each_entry(feat_desc, &cscfg_mgr->feat_desc_list, item) {
740 if (feat_desc->match_flags & match_flags) {
741 err = cscfg_load_feat_csdev(csdev, feat_desc, ops);
742 if (err)
743 break;
744 }
745 }
746 return err;
747}
748
749/* Add coresight device to list and copy its matching info */
750static int cscfg_list_add_csdev(struct coresight_device *csdev,
751 u32 match_flags,
752 struct cscfg_csdev_feat_ops *ops)
753{
754 struct cscfg_registered_csdev *csdev_item;
755
756 /* allocate the list entry structure */
757 csdev_item = kzalloc(sizeof(struct cscfg_registered_csdev), GFP_KERNEL);
758 if (!csdev_item)
759 return -ENOMEM;
760
761 csdev_item->csdev = csdev;
762 csdev_item->match_flags = match_flags;
763 csdev_item->ops.load_feat = ops->load_feat;
764 list_add(&csdev_item->item, &cscfg_mgr->csdev_desc_list);
765
766 INIT_LIST_HEAD(&csdev->feature_csdev_list);
767 INIT_LIST_HEAD(&csdev->config_csdev_list);
768 spin_lock_init(&csdev->cscfg_csdev_lock);
769
770 return 0;
771}
772
773/* remove a coresight device from the list and free data */
774static void cscfg_list_remove_csdev(struct coresight_device *csdev)
775{
776 struct cscfg_registered_csdev *csdev_item, *tmp;
777
778 list_for_each_entry_safe(csdev_item, tmp, &cscfg_mgr->csdev_desc_list, item) {
779 if (csdev_item->csdev == csdev) {
780 list_del(&csdev_item->item);
781 kfree(csdev_item);
782 break;
783 }
784 }
785}
786
787/**
788 * cscfg_register_csdev - register a coresight device with the syscfg manager.
789 *
790 * Registers the coresight device with the system. @match_flags used to check
791 * if the device is a match for registered features. Any currently registered
792 * configurations and features that match the device will be loaded onto it.
793 *
794 * @csdev: The coresight device to register.
795 * @match_flags: Matching information to load features.
796 * @ops: Standard operations supported by the device.
797 */
798int cscfg_register_csdev(struct coresight_device *csdev,
799 u32 match_flags,
800 struct cscfg_csdev_feat_ops *ops)
801{
802 int ret = 0;
803
804 mutex_lock(&cscfg_mutex);
805
806 /* add device to list of registered devices */
807 ret = cscfg_list_add_csdev(csdev, match_flags, ops);
808 if (ret)
809 goto reg_csdev_unlock;
810
811 /* now load any registered features and configs matching the device. */
812 ret = cscfg_add_feats_csdev(csdev, match_flags, ops);
813 if (ret) {
814 cscfg_list_remove_csdev(csdev);
815 goto reg_csdev_unlock;
816 }
817
818 ret = cscfg_add_cfgs_csdev(csdev);
819 if (ret) {
820 cscfg_list_remove_csdev(csdev);
821 goto reg_csdev_unlock;
822 }
823
824 pr_info("CSCFG registered %s", dev_name(&csdev->dev));
825
826reg_csdev_unlock:
827 mutex_unlock(&cscfg_mutex);
828 return ret;
829}
830EXPORT_SYMBOL_GPL(cscfg_register_csdev);
831
832/**
833 * cscfg_unregister_csdev - remove coresight device from syscfg manager.
834 *
835 * @csdev: Device to remove.
836 */
837void cscfg_unregister_csdev(struct coresight_device *csdev)
838{
839 mutex_lock(&cscfg_mutex);
840 cscfg_list_remove_csdev(csdev);
841 mutex_unlock(&cscfg_mutex);
842}
843EXPORT_SYMBOL_GPL(cscfg_unregister_csdev);
844
845/**
846 * cscfg_csdev_reset_feats - reset features for a CoreSight device.
847 *
848 * Resets all parameters and register values for any features loaded
849 * into @csdev to their default values.
850 *
851 * @csdev: The CoreSight device.
852 */
853void cscfg_csdev_reset_feats(struct coresight_device *csdev)
854{
855 struct cscfg_feature_csdev *feat_csdev;
856 unsigned long flags;
857
858 spin_lock_irqsave(&csdev->cscfg_csdev_lock, flags);
859 if (list_empty(&csdev->feature_csdev_list))
860 goto unlock_exit;
861
862 list_for_each_entry(feat_csdev, &csdev->feature_csdev_list, node)
863 cscfg_reset_feat(feat_csdev);
864
865unlock_exit:
866 spin_unlock_irqrestore(&csdev->cscfg_csdev_lock, flags);
867}
868EXPORT_SYMBOL_GPL(cscfg_csdev_reset_feats);
869
870/*
871 * This activate configuration for either perf or sysfs. Perf can have multiple
872 * active configs, selected per event, sysfs is limited to one.
873 *
874 * Increments the configuration descriptor active count and the global active
875 * count.
876 *
877 * @cfg_hash: Hash value of the selected configuration name.
878 */
879static int _cscfg_activate_config(unsigned long cfg_hash)
880{
881 struct cscfg_config_desc *config_desc;
882 int err = -EINVAL;
883
884 if (cscfg_mgr->load_state == CSCFG_UNLOAD)
885 return -EBUSY;
886
887 list_for_each_entry(config_desc, &cscfg_mgr->config_desc_list, item) {
888 if ((unsigned long)config_desc->event_ea->var == cfg_hash) {
889 /* if we happen upon a partly loaded config, can't use it */
890 if (config_desc->available == false)
891 return -EBUSY;
892
893 /* must ensure that config cannot be unloaded in use */
894 err = cscfg_owner_get(config_desc->load_owner);
895 if (err)
896 break;
897 /*
898 * increment the global active count - control changes to
899 * active configurations
900 */
901 atomic_inc(&cscfg_mgr->sys_active_cnt);
902
903 /*
904 * mark the descriptor as active so enable config on a
905 * device instance will use it
906 */
907 atomic_inc(&config_desc->active_cnt);
908
909 err = 0;
910 dev_dbg(cscfg_device(), "Activate config %s.\n", config_desc->name);
911 break;
912 }
913 }
914 return err;
915}
916
917static void _cscfg_deactivate_config(unsigned long cfg_hash)
918{
919 struct cscfg_config_desc *config_desc;
920
921 list_for_each_entry(config_desc, &cscfg_mgr->config_desc_list, item) {
922 if ((unsigned long)config_desc->event_ea->var == cfg_hash) {
923 atomic_dec(&config_desc->active_cnt);
924 atomic_dec(&cscfg_mgr->sys_active_cnt);
925 cscfg_owner_put(config_desc->load_owner);
926 dev_dbg(cscfg_device(), "Deactivate config %s.\n", config_desc->name);
927 break;
928 }
929 }
930}
931
932/*
933 * called from configfs to set/clear the active configuration for use when
934 * using sysfs to control trace.
935 */
936int cscfg_config_sysfs_activate(struct cscfg_config_desc *config_desc, bool activate)
937{
938 unsigned long cfg_hash;
939 int err = 0;
940
941 mutex_lock(&cscfg_mutex);
942
943 cfg_hash = (unsigned long)config_desc->event_ea->var;
944
945 if (activate) {
946 /* cannot be a current active value to activate this */
947 if (cscfg_mgr->sysfs_active_config) {
948 err = -EBUSY;
949 goto exit_unlock;
950 }
951 err = _cscfg_activate_config(cfg_hash);
952 if (!err)
953 cscfg_mgr->sysfs_active_config = cfg_hash;
954 } else {
955 /* disable if matching current value */
956 if (cscfg_mgr->sysfs_active_config == cfg_hash) {
957 _cscfg_deactivate_config(cfg_hash);
958 cscfg_mgr->sysfs_active_config = 0;
959 } else
960 err = -EINVAL;
961 }
962
963exit_unlock:
964 mutex_unlock(&cscfg_mutex);
965 return err;
966}
967
968/* set the sysfs preset value */
969void cscfg_config_sysfs_set_preset(int preset)
970{
971 mutex_lock(&cscfg_mutex);
972 cscfg_mgr->sysfs_active_preset = preset;
973 mutex_unlock(&cscfg_mutex);
974}
975
976/*
977 * Used by a device to get the config and preset selected as active in configfs,
978 * when using sysfs to control trace.
979 */
980void cscfg_config_sysfs_get_active_cfg(unsigned long *cfg_hash, int *preset)
981{
982 mutex_lock(&cscfg_mutex);
983 *preset = cscfg_mgr->sysfs_active_preset;
984 *cfg_hash = cscfg_mgr->sysfs_active_config;
985 mutex_unlock(&cscfg_mutex);
986}
987EXPORT_SYMBOL_GPL(cscfg_config_sysfs_get_active_cfg);
988
989/**
990 * cscfg_activate_config - Mark a configuration descriptor as active.
991 *
992 * This will be seen when csdev devices are enabled in the system.
993 * Only activated configurations can be enabled on individual devices.
994 * Activation protects the configuration from alteration or removal while
995 * active.
996 *
997 * Selection by hash value - generated from the configuration name when it
998 * was loaded and added to the cs_etm/configurations file system for selection
999 * by perf.
1000 *
1001 * @cfg_hash: Hash value of the selected configuration name.
1002 */
1003int cscfg_activate_config(unsigned long cfg_hash)
1004{
1005 int err = 0;
1006
1007 mutex_lock(&cscfg_mutex);
1008 err = _cscfg_activate_config(cfg_hash);
1009 mutex_unlock(&cscfg_mutex);
1010
1011 return err;
1012}
1013EXPORT_SYMBOL_GPL(cscfg_activate_config);
1014
1015/**
1016 * cscfg_deactivate_config - Mark a config descriptor as inactive.
1017 *
1018 * Decrement the configuration and global active counts.
1019 *
1020 * @cfg_hash: Hash value of the selected configuration name.
1021 */
1022void cscfg_deactivate_config(unsigned long cfg_hash)
1023{
1024 mutex_lock(&cscfg_mutex);
1025 _cscfg_deactivate_config(cfg_hash);
1026 mutex_unlock(&cscfg_mutex);
1027}
1028EXPORT_SYMBOL_GPL(cscfg_deactivate_config);
1029
1030/**
1031 * cscfg_csdev_enable_active_config - Enable matching active configuration for device.
1032 *
1033 * Enables the configuration selected by @cfg_hash if the configuration is supported
1034 * on the device and has been activated.
1035 *
1036 * If active and supported the CoreSight device @csdev will be programmed with the
1037 * configuration, using @preset parameters.
1038 *
1039 * Should be called before driver hardware enable for the requested device, prior to
1040 * programming and enabling the physical hardware.
1041 *
1042 * @csdev: CoreSight device to program.
1043 * @cfg_hash: Selector for the configuration.
1044 * @preset: Preset parameter values to use, 0 for current / default values.
1045 */
1046int cscfg_csdev_enable_active_config(struct coresight_device *csdev,
1047 unsigned long cfg_hash, int preset)
1048{
1049 struct cscfg_config_csdev *config_csdev_active = NULL, *config_csdev_item;
1050 const struct cscfg_config_desc *config_desc;
1051 unsigned long flags;
1052 int err = 0;
1053
1054 /* quickly check global count */
1055 if (!atomic_read(&cscfg_mgr->sys_active_cnt))
1056 return 0;
1057
1058 /*
1059 * Look for matching configuration - set the active configuration
1060 * context if found.
1061 */
1062 spin_lock_irqsave(&csdev->cscfg_csdev_lock, flags);
1063 list_for_each_entry(config_csdev_item, &csdev->config_csdev_list, node) {
1064 config_desc = config_csdev_item->config_desc;
1065 if ((atomic_read(&config_desc->active_cnt)) &&
1066 ((unsigned long)config_desc->event_ea->var == cfg_hash)) {
1067 config_csdev_active = config_csdev_item;
1068 csdev->active_cscfg_ctxt = (void *)config_csdev_active;
1069 break;
1070 }
1071 }
1072 spin_unlock_irqrestore(&csdev->cscfg_csdev_lock, flags);
1073
1074 /*
1075 * If found, attempt to enable
1076 */
1077 if (config_csdev_active) {
1078 /*
1079 * Call the generic routine that will program up the internal
1080 * driver structures prior to programming up the hardware.
1081 * This routine takes the driver spinlock saved in the configs.
1082 */
1083 err = cscfg_csdev_enable_config(config_csdev_active, preset);
1084 if (!err) {
1085 /*
1086 * Successful programming. Check the active_cscfg_ctxt
1087 * pointer to ensure no pre-emption disabled it via
1088 * cscfg_csdev_disable_active_config() before
1089 * we could start.
1090 *
1091 * Set enabled if OK, err if not.
1092 */
1093 spin_lock_irqsave(&csdev->cscfg_csdev_lock, flags);
1094 if (csdev->active_cscfg_ctxt)
1095 config_csdev_active->enabled = true;
1096 else
1097 err = -EBUSY;
1098 spin_unlock_irqrestore(&csdev->cscfg_csdev_lock, flags);
1099 }
1100 }
1101 return err;
1102}
1103EXPORT_SYMBOL_GPL(cscfg_csdev_enable_active_config);
1104
1105/**
1106 * cscfg_csdev_disable_active_config - disable an active config on the device.
1107 *
1108 * Disables the active configuration on the CoreSight device @csdev.
1109 * Disable will save the values of any registers marked in the configurations
1110 * as save on disable.
1111 *
1112 * Should be called after driver hardware disable for the requested device,
1113 * after disabling the physical hardware and reading back registers.
1114 *
1115 * @csdev: The CoreSight device.
1116 */
1117void cscfg_csdev_disable_active_config(struct coresight_device *csdev)
1118{
1119 struct cscfg_config_csdev *config_csdev;
1120 unsigned long flags;
1121
1122 /*
1123 * Check if we have an active config, and that it was successfully enabled.
1124 * If it was not enabled, we have no work to do, otherwise mark as disabled.
1125 * Clear the active config pointer.
1126 */
1127 spin_lock_irqsave(&csdev->cscfg_csdev_lock, flags);
1128 config_csdev = (struct cscfg_config_csdev *)csdev->active_cscfg_ctxt;
1129 if (config_csdev) {
1130 if (!config_csdev->enabled)
1131 config_csdev = NULL;
1132 else
1133 config_csdev->enabled = false;
1134 }
1135 csdev->active_cscfg_ctxt = NULL;
1136 spin_unlock_irqrestore(&csdev->cscfg_csdev_lock, flags);
1137
1138 /* true if there was an enabled active config */
1139 if (config_csdev)
1140 cscfg_csdev_disable_config(config_csdev);
1141}
1142EXPORT_SYMBOL_GPL(cscfg_csdev_disable_active_config);
1143
1144/* Initialise system configuration management device. */
1145
1146struct device *cscfg_device(void)
1147{
1148 return cscfg_mgr ? &cscfg_mgr->dev : NULL;
1149}
1150
1151/* Must have a release function or the kernel will complain on module unload */
1152static void cscfg_dev_release(struct device *dev)
1153{
1154 mutex_lock(&cscfg_mutex);
1155 kfree(cscfg_mgr);
1156 cscfg_mgr = NULL;
1157 mutex_unlock(&cscfg_mutex);
1158}
1159
1160/* a device is needed to "own" some kernel elements such as sysfs entries. */
1161static int cscfg_create_device(void)
1162{
1163 struct device *dev;
1164 int err = -ENOMEM;
1165
1166 mutex_lock(&cscfg_mutex);
1167 if (cscfg_mgr) {
1168 err = -EINVAL;
1169 goto create_dev_exit_unlock;
1170 }
1171
1172 cscfg_mgr = kzalloc(sizeof(struct cscfg_manager), GFP_KERNEL);
1173 if (!cscfg_mgr)
1174 goto create_dev_exit_unlock;
1175
1176 /* initialise the cscfg_mgr structure */
1177 INIT_LIST_HEAD(&cscfg_mgr->csdev_desc_list);
1178 INIT_LIST_HEAD(&cscfg_mgr->feat_desc_list);
1179 INIT_LIST_HEAD(&cscfg_mgr->config_desc_list);
1180 INIT_LIST_HEAD(&cscfg_mgr->load_order_list);
1181 atomic_set(&cscfg_mgr->sys_active_cnt, 0);
1182 cscfg_mgr->load_state = CSCFG_NONE;
1183
1184 /* setup the device */
1185 dev = cscfg_device();
1186 dev->release = cscfg_dev_release;
1187 dev->init_name = "cs_system_cfg";
1188
1189 err = device_register(dev);
1190 if (err)
1191 put_device(dev);
1192
1193create_dev_exit_unlock:
1194 mutex_unlock(&cscfg_mutex);
1195 return err;
1196}
1197
1198/*
1199 * Loading and unloading is generally on user discretion.
1200 * If exiting due to coresight module unload, we need to unload any configurations that remain,
1201 * before we unregister the configfs intrastructure.
1202 *
1203 * Do this by walking the load_owner list and taking appropriate action, depending on the load
1204 * owner type.
1205 */
1206static void cscfg_unload_cfgs_on_exit(void)
1207{
1208 struct cscfg_load_owner_info *owner_info = NULL;
1209
1210 /*
1211 * grab the mutex - even though we are exiting, some configfs files
1212 * may still be live till we dump them, so ensure list data is
1213 * protected from a race condition.
1214 */
1215 mutex_lock(&cscfg_mutex);
1216 while (!list_empty(&cscfg_mgr->load_order_list)) {
1217
1218 /* remove in reverse order of loading */
1219 owner_info = list_last_entry(&cscfg_mgr->load_order_list,
1220 struct cscfg_load_owner_info, item);
1221
1222 /* action according to type */
1223 switch (owner_info->type) {
1224 case CSCFG_OWNER_PRELOAD:
1225 /*
1226 * preloaded descriptors are statically allocated in
1227 * this module - just need to unload dynamic items from
1228 * csdev lists, and remove from configfs directories.
1229 */
1230 pr_info("cscfg: unloading preloaded configurations\n");
1231 break;
1232
1233 case CSCFG_OWNER_MODULE:
1234 /*
1235 * this is an error - the loadable module must have been unloaded prior
1236 * to the coresight module unload. Therefore that module has not
1237 * correctly unloaded configs in its own exit code.
1238 * Nothing to do other than emit an error string as the static descriptor
1239 * references we need to unload will have disappeared with the module.
1240 */
1241 pr_err("cscfg: ERROR: prior module failed to unload configuration\n");
1242 goto list_remove;
1243 }
1244
1245 /* remove from configfs - outside the scope of the list mutex */
1246 mutex_unlock(&cscfg_mutex);
1247 cscfg_fs_unregister_cfgs_feats(owner_info);
1248 mutex_lock(&cscfg_mutex);
1249
1250 /* Next unload from csdev lists. */
1251 cscfg_unload_owned_cfgs_feats(owner_info);
1252
1253list_remove:
1254 /* remove from load order list */
1255 list_del(&owner_info->item);
1256 }
1257 mutex_unlock(&cscfg_mutex);
1258}
1259
1260static void cscfg_clear_device(void)
1261{
1262 cscfg_unload_cfgs_on_exit();
1263 cscfg_configfs_release(cscfg_mgr);
1264 device_unregister(cscfg_device());
1265}
1266
1267/* Initialise system config management API device */
1268int __init cscfg_init(void)
1269{
1270 int err = 0;
1271
1272 /* create the device and init cscfg_mgr */
1273 err = cscfg_create_device();
1274 if (err)
1275 return err;
1276
1277 /* initialise configfs subsystem */
1278 err = cscfg_configfs_init(cscfg_mgr);
1279 if (err)
1280 goto exit_err;
1281
1282 /* preload built-in configurations */
1283 err = cscfg_preload(THIS_MODULE);
1284 if (err)
1285 goto exit_err;
1286
1287 dev_info(cscfg_device(), "CoreSight Configuration manager initialised");
1288 return 0;
1289
1290exit_err:
1291 cscfg_clear_device();
1292 return err;
1293}
1294
1295void cscfg_exit(void)
1296{
1297 cscfg_clear_device();
1298}