drivers/devfreq/devfreq-event.c

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