Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482// SPDX-License-Identifier: GPL-2.0-only/* * devfreq-event: a framework to provide raw data and events of devfreq devices * * Copyright (C) 2015 Samsung Electronics * Author: Chanwoo Choi <cw00.choi@samsung.com> * * This driver is based on drivers/devfreq/devfreq.c. */
#include <linux/devfreq-event.h>#include <linux/kernel.h>#include <linux/err.h>#include <linux/init.h>#include <linux/export.h>#include <linux/slab.h>#include <linux/list.h>#include <linux/of.h>
static struct attribute *devfreq_event_attrs[];ATTRIBUTE_GROUPS(devfreq_event);
static const struct class devfreq_event_class = { .name = "devfreq-event", .dev_groups = devfreq_event_groups};
/* The list of all devfreq event list */static LIST_HEAD(devfreq_event_list);static DEFINE_MUTEX(devfreq_event_list_lock);
#define to_devfreq_event(DEV) container_of(DEV, struct devfreq_event_dev, dev)
/** * devfreq_event_enable_edev() - Enable the devfreq-event dev and increase * the enable_count of devfreq-event dev. * @edev : the devfreq-event device * * Note that this function increase the enable_count and enable the * devfreq-event device. The devfreq-event device should be enabled before * using it by devfreq device. */int devfreq_event_enable_edev(struct devfreq_event_dev *edev){ int ret = 0;
if (!edev || !edev->desc) return -EINVAL;
mutex_lock(&edev->lock); if (edev->desc->ops && edev->desc->ops->enable && edev->enable_count == 0) { ret = edev->desc->ops->enable(edev); if (ret < 0) goto err; } edev->enable_count++;err: mutex_unlock(&edev->lock);
return ret;}EXPORT_SYMBOL_GPL(devfreq_event_enable_edev);
/** * devfreq_event_disable_edev() - Disable the devfreq-event dev and decrease * the enable_count of the devfreq-event dev. * @edev : the devfreq-event device * * Note that this function decrease the enable_count and disable the * devfreq-event device. After the devfreq-event device is disabled, * devfreq device can't use the devfreq-event device for get/set/reset * operations. */int devfreq_event_disable_edev(struct devfreq_event_dev *edev){ int ret = 0;
if (!edev || !edev->desc) return -EINVAL;
mutex_lock(&edev->lock); if (edev->enable_count <= 0) { dev_warn(&edev->dev, "unbalanced enable_count\n"); ret = -EIO; goto err; }
if (edev->desc->ops && edev->desc->ops->disable && edev->enable_count == 1) { ret = edev->desc->ops->disable(edev); if (ret < 0) goto err; } edev->enable_count--;err: mutex_unlock(&edev->lock);
return ret;}EXPORT_SYMBOL_GPL(devfreq_event_disable_edev);
/** * devfreq_event_is_enabled() - Check whether devfreq-event dev is enabled or * not. * @edev : the devfreq-event device * * Note that this function check whether devfreq-event dev is enabled or not. * If return true, the devfreq-event dev is enabeld. If return false, the * devfreq-event dev is disabled. */bool devfreq_event_is_enabled(struct devfreq_event_dev *edev){ bool enabled = false;
if (!edev || !edev->desc) return enabled;
mutex_lock(&edev->lock);
if (edev->enable_count > 0) enabled = true;
mutex_unlock(&edev->lock);
return enabled;}EXPORT_SYMBOL_GPL(devfreq_event_is_enabled);
/** * devfreq_event_set_event() - Set event to devfreq-event dev to start. * @edev : the devfreq-event device * * Note that this function set the event to the devfreq-event device to start * for getting the event data which could be various event type. */int devfreq_event_set_event(struct devfreq_event_dev *edev){ int ret;
if (!edev || !edev->desc) return -EINVAL;
if (!edev->desc->ops || !edev->desc->ops->set_event) return -EINVAL;
if (!devfreq_event_is_enabled(edev)) return -EPERM;
mutex_lock(&edev->lock); ret = edev->desc->ops->set_event(edev); mutex_unlock(&edev->lock);
return ret;}EXPORT_SYMBOL_GPL(devfreq_event_set_event);
/** * devfreq_event_get_event() - Get {load|total}_count from devfreq-event dev. * @edev : the devfreq-event device * @edata : the calculated data of devfreq-event device * * Note that this function get the calculated event data from devfreq-event dev * after stoping the progress of whole sequence of devfreq-event dev. */int devfreq_event_get_event(struct devfreq_event_dev *edev, struct devfreq_event_data *edata){ int ret;
if (!edev || !edev->desc) return -EINVAL;
if (!edev->desc->ops || !edev->desc->ops->get_event) return -EINVAL;
if (!devfreq_event_is_enabled(edev)) return -EINVAL;
edata->total_count = edata->load_count = 0;
mutex_lock(&edev->lock); ret = edev->desc->ops->get_event(edev, edata); if (ret < 0) edata->total_count = edata->load_count = 0; mutex_unlock(&edev->lock);
return ret;}EXPORT_SYMBOL_GPL(devfreq_event_get_event);
/** * devfreq_event_reset_event() - Reset all opeations of devfreq-event dev. * @edev : the devfreq-event device * * Note that this function stop all operations of devfreq-event dev and reset * the current event data to make the devfreq-event device into initial state. */int devfreq_event_reset_event(struct devfreq_event_dev *edev){ int ret = 0;
if (!edev || !edev->desc) return -EINVAL;
if (!devfreq_event_is_enabled(edev)) return -EPERM;
mutex_lock(&edev->lock); if (edev->desc->ops && edev->desc->ops->reset) ret = edev->desc->ops->reset(edev); mutex_unlock(&edev->lock);
return ret;}EXPORT_SYMBOL_GPL(devfreq_event_reset_event);
/** * devfreq_event_get_edev_by_phandle() - Get the devfreq-event dev from * devicetree. * @dev : the pointer to the given device * @phandle_name: name of property holding a phandle value * @index : the index into list of devfreq-event device * * Note that this function return the pointer of devfreq-event device. */struct devfreq_event_dev *devfreq_event_get_edev_by_phandle(struct device *dev, const char *phandle_name, int index){ struct device_node *node; struct devfreq_event_dev *edev;
if (!dev->of_node || !phandle_name) return ERR_PTR(-EINVAL);
node = of_parse_phandle(dev->of_node, phandle_name, index); if (!node) return ERR_PTR(-ENODEV);
mutex_lock(&devfreq_event_list_lock); list_for_each_entry(edev, &devfreq_event_list, node) { if (edev->dev.parent && device_match_of_node(edev->dev.parent, node)) goto out; }
list_for_each_entry(edev, &devfreq_event_list, node) { if (of_node_name_eq(node, edev->desc->name)) goto out; } edev = NULL;out: mutex_unlock(&devfreq_event_list_lock); of_node_put(node); if (!edev) return ERR_PTR(-ENODEV);
return edev;}EXPORT_SYMBOL_GPL(devfreq_event_get_edev_by_phandle);
/** * devfreq_event_get_edev_count() - Get the count of devfreq-event dev * @dev : the pointer to the given device * @phandle_name: name of property holding a phandle value * * Note that this function return the count of devfreq-event devices. */int devfreq_event_get_edev_count(struct device *dev, const char *phandle_name){ int count;
if (!dev->of_node || !phandle_name) { dev_err(dev, "device does not have a device node entry\n"); return -EINVAL; }
count = of_property_count_elems_of_size(dev->of_node, phandle_name, sizeof(u32)); if (count < 0) { dev_err(dev, "failed to get the count of devfreq-event in %pOF node\n", dev->of_node); return count; }
return count;}EXPORT_SYMBOL_GPL(devfreq_event_get_edev_count);
static void devfreq_event_release_edev(struct device *dev){ struct devfreq_event_dev *edev = to_devfreq_event(dev);
kfree(edev);}
/** * devfreq_event_add_edev() - Add new devfreq-event device. * @dev : the device owning the devfreq-event device being created * @desc : the devfreq-event device's descriptor which include essential * data for devfreq-event device. * * Note that this function add new devfreq-event device to devfreq-event class * list and register the device of the devfreq-event device. */struct devfreq_event_dev *devfreq_event_add_edev(struct device *dev, struct devfreq_event_desc *desc){ struct devfreq_event_dev *edev; static atomic_t event_no = ATOMIC_INIT(-1); int ret;
if (!dev || !desc) return ERR_PTR(-EINVAL);
if (!desc->name || !desc->ops) return ERR_PTR(-EINVAL);
if (!desc->ops->set_event || !desc->ops->get_event) return ERR_PTR(-EINVAL);
edev = kzalloc_obj(struct devfreq_event_dev); if (!edev) return ERR_PTR(-ENOMEM);
mutex_init(&edev->lock); edev->desc = desc; edev->enable_count = 0; edev->dev.parent = dev; edev->dev.class = &devfreq_event_class; edev->dev.release = devfreq_event_release_edev;
dev_set_name(&edev->dev, "event%d", atomic_inc_return(&event_no)); ret = device_register(&edev->dev); if (ret < 0) { put_device(&edev->dev); return ERR_PTR(ret); } dev_set_drvdata(&edev->dev, edev);
INIT_LIST_HEAD(&edev->node);
mutex_lock(&devfreq_event_list_lock); list_add(&edev->node, &devfreq_event_list); mutex_unlock(&devfreq_event_list_lock);
return edev;}EXPORT_SYMBOL_GPL(devfreq_event_add_edev);
/** * devfreq_event_remove_edev() - Remove the devfreq-event device registered. * @edev : the devfreq-event device * * Note that this function removes the registered devfreq-event device. */int devfreq_event_remove_edev(struct devfreq_event_dev *edev){ if (!edev) return -EINVAL;
WARN_ON(edev->enable_count);
mutex_lock(&devfreq_event_list_lock); list_del(&edev->node); mutex_unlock(&devfreq_event_list_lock);
device_unregister(&edev->dev);
return 0;}EXPORT_SYMBOL_GPL(devfreq_event_remove_edev);
static int devm_devfreq_event_match(struct device *dev, void *res, void *data){ struct devfreq_event_dev **r = res;
if (WARN_ON(!r || !*r)) return 0;
return *r == data;}
static void devm_devfreq_event_release(struct device *dev, void *res){ devfreq_event_remove_edev(*(struct devfreq_event_dev **)res);}
/** * devm_devfreq_event_add_edev() - Resource-managed devfreq_event_add_edev() * @dev : the device owning the devfreq-event device being created * @desc : the devfreq-event device's descriptor which include essential * data for devfreq-event device. * * Note that this function manages automatically the memory of devfreq-event * device using device resource management and simplify the free operation * for memory of devfreq-event device. */struct devfreq_event_dev *devm_devfreq_event_add_edev(struct device *dev, struct devfreq_event_desc *desc){ struct devfreq_event_dev **ptr, *edev;
ptr = devres_alloc(devm_devfreq_event_release, sizeof(*ptr), GFP_KERNEL); if (!ptr) return ERR_PTR(-ENOMEM);
edev = devfreq_event_add_edev(dev, desc); if (IS_ERR(edev)) { devres_free(ptr); return ERR_PTR(-ENOMEM); }
*ptr = edev; devres_add(dev, ptr);
return edev;}EXPORT_SYMBOL_GPL(devm_devfreq_event_add_edev);
/** * devm_devfreq_event_remove_edev()- Resource-managed devfreq_event_remove_edev() * @dev : the device owning the devfreq-event device being created * @edev : the devfreq-event device * * Note that this function manages automatically the memory of devfreq-event * device using device resource management. */void devm_devfreq_event_remove_edev(struct device *dev, struct devfreq_event_dev *edev){ WARN_ON(devres_release(dev, devm_devfreq_event_release, devm_devfreq_event_match, edev));}EXPORT_SYMBOL_GPL(devm_devfreq_event_remove_edev);
/* * Device attributes for devfreq-event class. */static ssize_t name_show(struct device *dev, struct device_attribute *attr, char *buf){ struct devfreq_event_dev *edev = to_devfreq_event(dev);
if (!edev || !edev->desc) return -EINVAL;
return sprintf(buf, "%s\n", edev->desc->name);}static DEVICE_ATTR_RO(name);
static ssize_t enable_count_show(struct device *dev, struct device_attribute *attr, char *buf){ struct devfreq_event_dev *edev = to_devfreq_event(dev);
if (!edev || !edev->desc) return -EINVAL;
return sprintf(buf, "%d\n", edev->enable_count);}static DEVICE_ATTR_RO(enable_count);
static struct attribute *devfreq_event_attrs[] = { &dev_attr_name.attr, &dev_attr_enable_count.attr, NULL,};
static int __init devfreq_event_init(void){ int err;
err = class_register(&devfreq_event_class); if (err) pr_err("%s: couldn't create class\n", __FILE__);
return err;}subsys_initcall(devfreq_event_init);