blob: 38bf144ca1479840947b0f3321f7fe0e0ea49042 [file] [log] [blame]
Chanwoo Choif262f282015-01-26 13:16:27 +09001/*
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
23static struct class *devfreq_event_class;
24
25/* The list of all devfreq event list */
26static LIST_HEAD(devfreq_event_list);
27static 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 */
40int 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++;
55err:
56 mutex_unlock(&edev->lock);
57
58 return ret;
59}
60EXPORT_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 */
72int 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--;
93err:
94 mutex_unlock(&edev->lock);
95
96 return ret;
97}
98EXPORT_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 */
109bool 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}
125EXPORT_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 */
134int 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}
153EXPORT_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 */
163int 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}
187EXPORT_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 */
196int 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}
213EXPORT_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 */
223struct 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
Chanwoo Choidf678ff2015-11-17 14:25:06 +0900229 if (!dev->of_node)
Chanwoo Choif262f282015-01-26 13:16:27 +0900230 return ERR_PTR(-EINVAL);
Chanwoo Choif262f282015-01-26 13:16:27 +0900231
232 node = of_parse_phandle(dev->of_node, "devfreq-events", index);
Chanwoo Choidf678ff2015-11-17 14:25:06 +0900233 if (!node)
Chanwoo Choif262f282015-01-26 13:16:27 +0900234 return ERR_PTR(-ENODEV);
Chanwoo Choif262f282015-01-26 13:16:27 +0900235
236 mutex_lock(&devfreq_event_list_lock);
237 list_for_each_entry(edev, &devfreq_event_list, node) {
238 if (!strcmp(edev->desc->name, node->name))
239 goto out;
240 }
241 edev = NULL;
242out:
243 mutex_unlock(&devfreq_event_list_lock);
244
245 if (!edev) {
Chanwoo Choif262f282015-01-26 13:16:27 +0900246 of_node_put(node);
247 return ERR_PTR(-ENODEV);
248 }
249
250 of_node_put(node);
251
252 return edev;
253}
254EXPORT_SYMBOL_GPL(devfreq_event_get_edev_by_phandle);
255
256/**
257 * devfreq_event_get_edev_count() - Get the count of devfreq-event dev
258 * @dev : the pointer to the given device
259 *
260 * Note that this function return the count of devfreq-event devices.
261 */
262int devfreq_event_get_edev_count(struct device *dev)
263{
264 int count;
265
266 if (!dev->of_node) {
267 dev_err(dev, "device does not have a device node entry\n");
268 return -EINVAL;
269 }
270
271 count = of_property_count_elems_of_size(dev->of_node, "devfreq-events",
272 sizeof(u32));
Chanwoo Choie54916c2015-11-19 17:03:44 +0900273 if (count < 0) {
Chanwoo Choif262f282015-01-26 13:16:27 +0900274 dev_err(dev,
275 "failed to get the count of devfreq-event in %s node\n",
276 dev->of_node->full_name);
277 return count;
278 }
279
280 return count;
281}
282EXPORT_SYMBOL_GPL(devfreq_event_get_edev_count);
283
284static void devfreq_event_release_edev(struct device *dev)
285{
286 struct devfreq_event_dev *edev = to_devfreq_event(dev);
287
288 kfree(edev);
289}
290
291/**
292 * devfreq_event_add_edev() - Add new devfreq-event device.
293 * @dev : the device owning the devfreq-event device being created
294 * @desc : the devfreq-event device's decriptor which include essential
295 * data for devfreq-event device.
296 *
297 * Note that this function add new devfreq-event device to devfreq-event class
298 * list and register the device of the devfreq-event device.
299 */
300struct devfreq_event_dev *devfreq_event_add_edev(struct device *dev,
301 struct devfreq_event_desc *desc)
302{
303 struct devfreq_event_dev *edev;
304 static atomic_t event_no = ATOMIC_INIT(0);
305 int ret;
306
307 if (!dev || !desc)
308 return ERR_PTR(-EINVAL);
309
310 if (!desc->name || !desc->ops)
311 return ERR_PTR(-EINVAL);
312
313 if (!desc->ops->set_event || !desc->ops->get_event)
314 return ERR_PTR(-EINVAL);
315
316 edev = kzalloc(sizeof(struct devfreq_event_dev), GFP_KERNEL);
317 if (!edev)
318 return ERR_PTR(-ENOMEM);
319
320 mutex_init(&edev->lock);
321 edev->desc = desc;
322 edev->enable_count = 0;
323 edev->dev.parent = dev;
324 edev->dev.class = devfreq_event_class;
325 edev->dev.release = devfreq_event_release_edev;
326
327 dev_set_name(&edev->dev, "event.%d", atomic_inc_return(&event_no) - 1);
328 ret = device_register(&edev->dev);
329 if (ret < 0) {
330 put_device(&edev->dev);
331 return ERR_PTR(ret);
332 }
333 dev_set_drvdata(&edev->dev, edev);
334
335 INIT_LIST_HEAD(&edev->node);
336
337 mutex_lock(&devfreq_event_list_lock);
338 list_add(&edev->node, &devfreq_event_list);
339 mutex_unlock(&devfreq_event_list_lock);
340
341 return edev;
342}
343EXPORT_SYMBOL_GPL(devfreq_event_add_edev);
344
345/**
346 * devfreq_event_remove_edev() - Remove the devfreq-event device registered.
347 * @dev : the devfreq-event device
348 *
349 * Note that this function remove the registered devfreq-event device.
350 */
351int devfreq_event_remove_edev(struct devfreq_event_dev *edev)
352{
353 if (!edev)
354 return -EINVAL;
355
356 WARN_ON(edev->enable_count);
357
358 mutex_lock(&devfreq_event_list_lock);
359 list_del(&edev->node);
360 mutex_unlock(&devfreq_event_list_lock);
361
362 device_unregister(&edev->dev);
363
364 return 0;
365}
366EXPORT_SYMBOL_GPL(devfreq_event_remove_edev);
367
368static int devm_devfreq_event_match(struct device *dev, void *res, void *data)
369{
370 struct devfreq_event_dev **r = res;
371
372 if (WARN_ON(!r || !*r))
373 return 0;
374
375 return *r == data;
376}
377
378static void devm_devfreq_event_release(struct device *dev, void *res)
379{
380 devfreq_event_remove_edev(*(struct devfreq_event_dev **)res);
381}
382
383/**
384 * devm_devfreq_event_add_edev() - Resource-managed devfreq_event_add_edev()
385 * @dev : the device owning the devfreq-event device being created
386 * @desc : the devfreq-event device's decriptor which include essential
387 * data for devfreq-event device.
388 *
389 * Note that this function manages automatically the memory of devfreq-event
390 * device using device resource management and simplify the free operation
391 * for memory of devfreq-event device.
392 */
393struct devfreq_event_dev *devm_devfreq_event_add_edev(struct device *dev,
394 struct devfreq_event_desc *desc)
395{
396 struct devfreq_event_dev **ptr, *edev;
397
Chanwoo Choie54916c2015-11-19 17:03:44 +0900398 ptr = devres_alloc(devm_devfreq_event_release, sizeof(*ptr),
399 GFP_KERNEL);
Chanwoo Choif262f282015-01-26 13:16:27 +0900400 if (!ptr)
401 return ERR_PTR(-ENOMEM);
402
403 edev = devfreq_event_add_edev(dev, desc);
404 if (IS_ERR(edev)) {
405 devres_free(ptr);
406 return ERR_PTR(-ENOMEM);
407 }
408
409 *ptr = edev;
410 devres_add(dev, ptr);
411
412 return edev;
413}
414EXPORT_SYMBOL_GPL(devm_devfreq_event_add_edev);
415
416/**
417 * devm_devfreq_event_remove_edev()- Resource-managed devfreq_event_remove_edev()
418 * @dev : the device owning the devfreq-event device being created
419 * @edev : the devfreq-event device
420 *
421 * Note that this function manages automatically the memory of devfreq-event
422 * device using device resource management.
423 */
424void devm_devfreq_event_remove_edev(struct device *dev,
425 struct devfreq_event_dev *edev)
426{
427 WARN_ON(devres_release(dev, devm_devfreq_event_release,
428 devm_devfreq_event_match, edev));
429}
430EXPORT_SYMBOL_GPL(devm_devfreq_event_remove_edev);
431
432/*
433 * Device attributes for devfreq-event class.
434 */
435static ssize_t name_show(struct device *dev, struct device_attribute *attr,
436 char *buf)
437{
438 struct devfreq_event_dev *edev = to_devfreq_event(dev);
439
440 if (!edev || !edev->desc)
441 return -EINVAL;
442
443 return sprintf(buf, "%s\n", edev->desc->name);
444}
445static DEVICE_ATTR_RO(name);
446
447static ssize_t enable_count_show(struct device *dev,
448 struct device_attribute *attr, char *buf)
449{
450 struct devfreq_event_dev *edev = to_devfreq_event(dev);
451
452 if (!edev || !edev->desc)
453 return -EINVAL;
454
455 return sprintf(buf, "%d\n", edev->enable_count);
456}
457static DEVICE_ATTR_RO(enable_count);
458
459static struct attribute *devfreq_event_attrs[] = {
460 &dev_attr_name.attr,
461 &dev_attr_enable_count.attr,
462 NULL,
463};
464ATTRIBUTE_GROUPS(devfreq_event);
465
466static int __init devfreq_event_init(void)
467{
468 devfreq_event_class = class_create(THIS_MODULE, "devfreq-event");
469 if (IS_ERR(devfreq_event_class)) {
470 pr_err("%s: couldn't create class\n", __FILE__);
471 return PTR_ERR(devfreq_event_class);
472 }
473
474 devfreq_event_class->dev_groups = devfreq_event_groups;
475
476 return 0;
477}
478subsys_initcall(devfreq_event_init);
479
480static void __exit devfreq_event_exit(void)
481{
482 class_destroy(devfreq_event_class);
483}
484module_exit(devfreq_event_exit);
485
486MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>");
487MODULE_DESCRIPTION("DEVFREQ-Event class support");
488MODULE_LICENSE("GPL");