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 20 static struct class *devfreq_event_class; 21 22 /* The list of all devfreq event list */ 23 static LIST_HEAD(devfreq_event_list); 24 static 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 */ 37 int 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++; 52 err: 53 mutex_unlock(&edev->lock); 54 55 return ret; 56 } 57 EXPORT_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 */ 69 int 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--; 90 err: 91 mutex_unlock(&edev->lock); 92 93 return ret; 94 } 95 EXPORT_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 */ 106 bool 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 } 122 EXPORT_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 */ 131 int 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 } 150 EXPORT_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 */ 160 int 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 } 184 EXPORT_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 */ 193 int 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 } 210 EXPORT_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 */ 221 struct 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; 245 out: 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 } 257 EXPORT_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 */ 266 int 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 } 286 EXPORT_SYMBOL_GPL(devfreq_event_get_edev_count); 287 288 static 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 */ 304 struct 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 } 347 EXPORT_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 */ 355 int 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 } 370 EXPORT_SYMBOL_GPL(devfreq_event_remove_edev); 371 372 static 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 382 static 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 */ 397 struct 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 } 418 EXPORT_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 */ 428 void 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 } 434 EXPORT_SYMBOL_GPL(devm_devfreq_event_remove_edev); 435 436 /* 437 * Device attributes for devfreq-event class. 438 */ 439 static 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 } 449 static DEVICE_ATTR_RO(name); 450 451 static 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 } 461 static DEVICE_ATTR_RO(enable_count); 462 463 static struct attribute *devfreq_event_attrs[] = { 464 &dev_attr_name.attr, 465 &dev_attr_enable_count.attr, 466 NULL, 467 }; 468 ATTRIBUTE_GROUPS(devfreq_event); 469 470 static 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 } 482 subsys_initcall(devfreq_event_init); 483