483 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * devfreq-event: a framework to provide raw data and events of devfreq devices4 *5 * Copyright (C) 2015 Samsung Electronics6 * 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 increase30 * the enable_count of devfreq-event dev.31 * @edev : the devfreq-event device32 *33 * Note that this function increase the enable_count and enable the34 * devfreq-event device. The devfreq-event device should be enabled before35 * 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->enable46 && 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 decrease61 * the enable_count of the devfreq-event dev.62 * @edev : the devfreq-event device63 *64 * Note that this function decrease the enable_count and disable the65 * devfreq-event device. After the devfreq-event device is disabled,66 * devfreq device can't use the devfreq-event device for get/set/reset67 * 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->disable84 && 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 or99 * not.100 * @edev : the devfreq-event device101 *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, the104 * 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 device127 *128 * Note that this function set the event to the devfreq-event device to start129 * 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 device155 * @edata : the calculated data of devfreq-event device156 *157 * Note that this function get the calculated event data from devfreq-event dev158 * 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 device189 *190 * Note that this function stop all operations of devfreq-event dev and reset191 * 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 from214 * devicetree.215 * @dev : the pointer to the given device216 * @phandle_name: name of property holding a phandle value217 * @index : the index into list of devfreq-event device218 *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 && device_match_of_node(edev->dev.parent, 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 dev261 * @dev : the pointer to the given device262 * @phandle_name: name of property holding a phandle value263 *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 created298 * @desc : the devfreq-event device's descriptor which include essential299 * data for devfreq-event device.300 *301 * Note that this function add new devfreq-event device to devfreq-event class302 * 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 device352 *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 created390 * @desc : the devfreq-event device's descriptor which include essential391 * data for devfreq-event device.392 *393 * Note that this function manages automatically the memory of devfreq-event394 * device using device resource management and simplify the free operation395 * 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 created423 * @edev : the devfreq-event device424 *425 * Note that this function manages automatically the memory of devfreq-event426 * 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("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);483