cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

devfreq-event.c (12337B)


      1// SPDX-License-Identifier: GPL-2.0-only
      2/*
      3 * devfreq-event: a framework to provide raw data and events of devfreq devices
      4 *
      5 * Copyright (C) 2015 Samsung Electronics
      6 * Author: Chanwoo Choi <cw00.choi@samsung.com>
      7 *
      8 * This driver is based on drivers/devfreq/devfreq.c.
      9 */
     10
     11#include <linux/devfreq-event.h>
     12#include <linux/kernel.h>
     13#include <linux/err.h>
     14#include <linux/init.h>
     15#include <linux/export.h>
     16#include <linux/slab.h>
     17#include <linux/list.h>
     18#include <linux/of.h>
     19
     20static struct class *devfreq_event_class;
     21
     22/* The list of all devfreq event list */
     23static LIST_HEAD(devfreq_event_list);
     24static DEFINE_MUTEX(devfreq_event_list_lock);
     25
     26#define to_devfreq_event(DEV) container_of(DEV, struct devfreq_event_dev, dev)
     27
     28/**
     29 * devfreq_event_enable_edev() - Enable the devfreq-event dev and increase
     30 *				 the enable_count of devfreq-event dev.
     31 * @edev	: the devfreq-event device
     32 *
     33 * Note that this function increase the enable_count and enable the
     34 * devfreq-event device. The devfreq-event device should be enabled before
     35 * using it by devfreq device.
     36 */
     37int devfreq_event_enable_edev(struct devfreq_event_dev *edev)
     38{
     39	int ret = 0;
     40
     41	if (!edev || !edev->desc)
     42		return -EINVAL;
     43
     44	mutex_lock(&edev->lock);
     45	if (edev->desc->ops && edev->desc->ops->enable
     46			&& edev->enable_count == 0) {
     47		ret = edev->desc->ops->enable(edev);
     48		if (ret < 0)
     49			goto err;
     50	}
     51	edev->enable_count++;
     52err:
     53	mutex_unlock(&edev->lock);
     54
     55	return ret;
     56}
     57EXPORT_SYMBOL_GPL(devfreq_event_enable_edev);
     58
     59/**
     60 * devfreq_event_disable_edev() - Disable the devfreq-event dev and decrease
     61 *				  the enable_count of the devfreq-event dev.
     62 * @edev	: the devfreq-event device
     63 *
     64 * Note that this function decrease the enable_count and disable the
     65 * devfreq-event device. After the devfreq-event device is disabled,
     66 * devfreq device can't use the devfreq-event device for get/set/reset
     67 * operations.
     68 */
     69int devfreq_event_disable_edev(struct devfreq_event_dev *edev)
     70{
     71	int ret = 0;
     72
     73	if (!edev || !edev->desc)
     74		return -EINVAL;
     75
     76	mutex_lock(&edev->lock);
     77	if (edev->enable_count <= 0) {
     78		dev_warn(&edev->dev, "unbalanced enable_count\n");
     79		ret = -EIO;
     80		goto err;
     81	}
     82
     83	if (edev->desc->ops && edev->desc->ops->disable
     84			&& edev->enable_count == 1) {
     85		ret = edev->desc->ops->disable(edev);
     86		if (ret < 0)
     87			goto err;
     88	}
     89	edev->enable_count--;
     90err:
     91	mutex_unlock(&edev->lock);
     92
     93	return ret;
     94}
     95EXPORT_SYMBOL_GPL(devfreq_event_disable_edev);
     96
     97/**
     98 * devfreq_event_is_enabled() - Check whether devfreq-event dev is enabled or
     99 *				not.
    100 * @edev	: the devfreq-event device
    101 *
    102 * Note that this function check whether devfreq-event dev is enabled or not.
    103 * If return true, the devfreq-event dev is enabeld. If return false, the
    104 * devfreq-event dev is disabled.
    105 */
    106bool devfreq_event_is_enabled(struct devfreq_event_dev *edev)
    107{
    108	bool enabled = false;
    109
    110	if (!edev || !edev->desc)
    111		return enabled;
    112
    113	mutex_lock(&edev->lock);
    114
    115	if (edev->enable_count > 0)
    116		enabled = true;
    117
    118	mutex_unlock(&edev->lock);
    119
    120	return enabled;
    121}
    122EXPORT_SYMBOL_GPL(devfreq_event_is_enabled);
    123
    124/**
    125 * devfreq_event_set_event() - Set event to devfreq-event dev to start.
    126 * @edev	: the devfreq-event device
    127 *
    128 * Note that this function set the event to the devfreq-event device to start
    129 * for getting the event data which could be various event type.
    130 */
    131int devfreq_event_set_event(struct devfreq_event_dev *edev)
    132{
    133	int ret;
    134
    135	if (!edev || !edev->desc)
    136		return -EINVAL;
    137
    138	if (!edev->desc->ops || !edev->desc->ops->set_event)
    139		return -EINVAL;
    140
    141	if (!devfreq_event_is_enabled(edev))
    142		return -EPERM;
    143
    144	mutex_lock(&edev->lock);
    145	ret = edev->desc->ops->set_event(edev);
    146	mutex_unlock(&edev->lock);
    147
    148	return ret;
    149}
    150EXPORT_SYMBOL_GPL(devfreq_event_set_event);
    151
    152/**
    153 * devfreq_event_get_event() - Get {load|total}_count from devfreq-event dev.
    154 * @edev	: the devfreq-event device
    155 * @edata	: the calculated data of devfreq-event device
    156 *
    157 * Note that this function get the calculated event data from devfreq-event dev
    158 * after stoping the progress of whole sequence of devfreq-event dev.
    159 */
    160int devfreq_event_get_event(struct devfreq_event_dev *edev,
    161			    struct devfreq_event_data *edata)
    162{
    163	int ret;
    164
    165	if (!edev || !edev->desc)
    166		return -EINVAL;
    167
    168	if (!edev->desc->ops || !edev->desc->ops->get_event)
    169		return -EINVAL;
    170
    171	if (!devfreq_event_is_enabled(edev))
    172		return -EINVAL;
    173
    174	edata->total_count = edata->load_count = 0;
    175
    176	mutex_lock(&edev->lock);
    177	ret = edev->desc->ops->get_event(edev, edata);
    178	if (ret < 0)
    179		edata->total_count = edata->load_count = 0;
    180	mutex_unlock(&edev->lock);
    181
    182	return ret;
    183}
    184EXPORT_SYMBOL_GPL(devfreq_event_get_event);
    185
    186/**
    187 * devfreq_event_reset_event() - Reset all opeations of devfreq-event dev.
    188 * @edev	: the devfreq-event device
    189 *
    190 * Note that this function stop all operations of devfreq-event dev and reset
    191 * the current event data to make the devfreq-event device into initial state.
    192 */
    193int devfreq_event_reset_event(struct devfreq_event_dev *edev)
    194{
    195	int ret = 0;
    196
    197	if (!edev || !edev->desc)
    198		return -EINVAL;
    199
    200	if (!devfreq_event_is_enabled(edev))
    201		return -EPERM;
    202
    203	mutex_lock(&edev->lock);
    204	if (edev->desc->ops && edev->desc->ops->reset)
    205		ret = edev->desc->ops->reset(edev);
    206	mutex_unlock(&edev->lock);
    207
    208	return ret;
    209}
    210EXPORT_SYMBOL_GPL(devfreq_event_reset_event);
    211
    212/**
    213 * devfreq_event_get_edev_by_phandle() - Get the devfreq-event dev from
    214 *					 devicetree.
    215 * @dev		: the pointer to the given device
    216 * @phandle_name: name of property holding a phandle value
    217 * @index	: the index into list of devfreq-event device
    218 *
    219 * Note that this function return the pointer of devfreq-event device.
    220 */
    221struct devfreq_event_dev *devfreq_event_get_edev_by_phandle(struct device *dev,
    222					const char *phandle_name, int index)
    223{
    224	struct device_node *node;
    225	struct devfreq_event_dev *edev;
    226
    227	if (!dev->of_node || !phandle_name)
    228		return ERR_PTR(-EINVAL);
    229
    230	node = of_parse_phandle(dev->of_node, phandle_name, index);
    231	if (!node)
    232		return ERR_PTR(-ENODEV);
    233
    234	mutex_lock(&devfreq_event_list_lock);
    235	list_for_each_entry(edev, &devfreq_event_list, node) {
    236		if (edev->dev.parent && edev->dev.parent->of_node == node)
    237			goto out;
    238	}
    239
    240	list_for_each_entry(edev, &devfreq_event_list, node) {
    241		if (of_node_name_eq(node, edev->desc->name))
    242			goto out;
    243	}
    244	edev = NULL;
    245out:
    246	mutex_unlock(&devfreq_event_list_lock);
    247
    248	if (!edev) {
    249		of_node_put(node);
    250		return ERR_PTR(-ENODEV);
    251	}
    252
    253	of_node_put(node);
    254
    255	return edev;
    256}
    257EXPORT_SYMBOL_GPL(devfreq_event_get_edev_by_phandle);
    258
    259/**
    260 * devfreq_event_get_edev_count() - Get the count of devfreq-event dev
    261 * @dev		: the pointer to the given device
    262 * @phandle_name: name of property holding a phandle value
    263 *
    264 * Note that this function return the count of devfreq-event devices.
    265 */
    266int devfreq_event_get_edev_count(struct device *dev, const char *phandle_name)
    267{
    268	int count;
    269
    270	if (!dev->of_node || !phandle_name) {
    271		dev_err(dev, "device does not have a device node entry\n");
    272		return -EINVAL;
    273	}
    274
    275	count = of_property_count_elems_of_size(dev->of_node, phandle_name,
    276						sizeof(u32));
    277	if (count < 0) {
    278		dev_err(dev,
    279			"failed to get the count of devfreq-event in %pOF node\n",
    280			dev->of_node);
    281		return count;
    282	}
    283
    284	return count;
    285}
    286EXPORT_SYMBOL_GPL(devfreq_event_get_edev_count);
    287
    288static void devfreq_event_release_edev(struct device *dev)
    289{
    290	struct devfreq_event_dev *edev = to_devfreq_event(dev);
    291
    292	kfree(edev);
    293}
    294
    295/**
    296 * devfreq_event_add_edev() - Add new devfreq-event device.
    297 * @dev		: the device owning the devfreq-event device being created
    298 * @desc	: the devfreq-event device's descriptor which include essential
    299 *		  data for devfreq-event device.
    300 *
    301 * Note that this function add new devfreq-event device to devfreq-event class
    302 * list and register the device of the devfreq-event device.
    303 */
    304struct devfreq_event_dev *devfreq_event_add_edev(struct device *dev,
    305						struct devfreq_event_desc *desc)
    306{
    307	struct devfreq_event_dev *edev;
    308	static atomic_t event_no = ATOMIC_INIT(-1);
    309	int ret;
    310
    311	if (!dev || !desc)
    312		return ERR_PTR(-EINVAL);
    313
    314	if (!desc->name || !desc->ops)
    315		return ERR_PTR(-EINVAL);
    316
    317	if (!desc->ops->set_event || !desc->ops->get_event)
    318		return ERR_PTR(-EINVAL);
    319
    320	edev = kzalloc(sizeof(struct devfreq_event_dev), GFP_KERNEL);
    321	if (!edev)
    322		return ERR_PTR(-ENOMEM);
    323
    324	mutex_init(&edev->lock);
    325	edev->desc = desc;
    326	edev->enable_count = 0;
    327	edev->dev.parent = dev;
    328	edev->dev.class = devfreq_event_class;
    329	edev->dev.release = devfreq_event_release_edev;
    330
    331	dev_set_name(&edev->dev, "event%d", atomic_inc_return(&event_no));
    332	ret = device_register(&edev->dev);
    333	if (ret < 0) {
    334		put_device(&edev->dev);
    335		return ERR_PTR(ret);
    336	}
    337	dev_set_drvdata(&edev->dev, edev);
    338
    339	INIT_LIST_HEAD(&edev->node);
    340
    341	mutex_lock(&devfreq_event_list_lock);
    342	list_add(&edev->node, &devfreq_event_list);
    343	mutex_unlock(&devfreq_event_list_lock);
    344
    345	return edev;
    346}
    347EXPORT_SYMBOL_GPL(devfreq_event_add_edev);
    348
    349/**
    350 * devfreq_event_remove_edev() - Remove the devfreq-event device registered.
    351 * @edev	: the devfreq-event device
    352 *
    353 * Note that this function removes the registered devfreq-event device.
    354 */
    355int devfreq_event_remove_edev(struct devfreq_event_dev *edev)
    356{
    357	if (!edev)
    358		return -EINVAL;
    359
    360	WARN_ON(edev->enable_count);
    361
    362	mutex_lock(&devfreq_event_list_lock);
    363	list_del(&edev->node);
    364	mutex_unlock(&devfreq_event_list_lock);
    365
    366	device_unregister(&edev->dev);
    367
    368	return 0;
    369}
    370EXPORT_SYMBOL_GPL(devfreq_event_remove_edev);
    371
    372static int devm_devfreq_event_match(struct device *dev, void *res, void *data)
    373{
    374	struct devfreq_event_dev **r = res;
    375
    376	if (WARN_ON(!r || !*r))
    377		return 0;
    378
    379	return *r == data;
    380}
    381
    382static void devm_devfreq_event_release(struct device *dev, void *res)
    383{
    384	devfreq_event_remove_edev(*(struct devfreq_event_dev **)res);
    385}
    386
    387/**
    388 * devm_devfreq_event_add_edev() - Resource-managed devfreq_event_add_edev()
    389 * @dev		: the device owning the devfreq-event device being created
    390 * @desc	: the devfreq-event device's descriptor which include essential
    391 *		  data for devfreq-event device.
    392 *
    393 * Note that this function manages automatically the memory of devfreq-event
    394 * device using device resource management and simplify the free operation
    395 * for memory of devfreq-event device.
    396 */
    397struct devfreq_event_dev *devm_devfreq_event_add_edev(struct device *dev,
    398						struct devfreq_event_desc *desc)
    399{
    400	struct devfreq_event_dev **ptr, *edev;
    401
    402	ptr = devres_alloc(devm_devfreq_event_release, sizeof(*ptr),
    403				GFP_KERNEL);
    404	if (!ptr)
    405		return ERR_PTR(-ENOMEM);
    406
    407	edev = devfreq_event_add_edev(dev, desc);
    408	if (IS_ERR(edev)) {
    409		devres_free(ptr);
    410		return ERR_PTR(-ENOMEM);
    411	}
    412
    413	*ptr = edev;
    414	devres_add(dev, ptr);
    415
    416	return edev;
    417}
    418EXPORT_SYMBOL_GPL(devm_devfreq_event_add_edev);
    419
    420/**
    421 * devm_devfreq_event_remove_edev()- Resource-managed devfreq_event_remove_edev()
    422 * @dev		: the device owning the devfreq-event device being created
    423 * @edev	: the devfreq-event device
    424 *
    425 * Note that this function manages automatically the memory of devfreq-event
    426 * device using device resource management.
    427 */
    428void devm_devfreq_event_remove_edev(struct device *dev,
    429				struct devfreq_event_dev *edev)
    430{
    431	WARN_ON(devres_release(dev, devm_devfreq_event_release,
    432			       devm_devfreq_event_match, edev));
    433}
    434EXPORT_SYMBOL_GPL(devm_devfreq_event_remove_edev);
    435
    436/*
    437 * Device attributes for devfreq-event class.
    438 */
    439static ssize_t name_show(struct device *dev, struct device_attribute *attr,
    440			 char *buf)
    441{
    442	struct devfreq_event_dev *edev = to_devfreq_event(dev);
    443
    444	if (!edev || !edev->desc)
    445		return -EINVAL;
    446
    447	return sprintf(buf, "%s\n", edev->desc->name);
    448}
    449static DEVICE_ATTR_RO(name);
    450
    451static ssize_t enable_count_show(struct device *dev,
    452				  struct device_attribute *attr, char *buf)
    453{
    454	struct devfreq_event_dev *edev = to_devfreq_event(dev);
    455
    456	if (!edev || !edev->desc)
    457		return -EINVAL;
    458
    459	return sprintf(buf, "%d\n", edev->enable_count);
    460}
    461static DEVICE_ATTR_RO(enable_count);
    462
    463static struct attribute *devfreq_event_attrs[] = {
    464	&dev_attr_name.attr,
    465	&dev_attr_enable_count.attr,
    466	NULL,
    467};
    468ATTRIBUTE_GROUPS(devfreq_event);
    469
    470static int __init devfreq_event_init(void)
    471{
    472	devfreq_event_class = class_create(THIS_MODULE, "devfreq-event");
    473	if (IS_ERR(devfreq_event_class)) {
    474		pr_err("%s: couldn't create class\n", __FILE__);
    475		return PTR_ERR(devfreq_event_class);
    476	}
    477
    478	devfreq_event_class->dev_groups = devfreq_event_groups;
    479
    480	return 0;
    481}
    482subsys_initcall(devfreq_event_init);