projects/linux·blob master · refs

481 lines · 12.0 KiB

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 <[email protected]>
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 attribute *devfreq_event_attrs[];
21ATTRIBUTE_GROUPS(devfreq_event);
22
23static const struct class devfreq_event_class = {
24 .name = "devfreq-event",
25 .dev_groups = devfreq_event_groups
26};
27
28/* The list of all devfreq event list */
29static LIST_HEAD(devfreq_event_list);
30static DEFINE_MUTEX(devfreq_event_list_lock);
31
32#define to_devfreq_event(DEV) container_of(DEV, struct devfreq_event_dev, dev)
33
34/**
35 * devfreq_event_enable_edev() - Enable the devfreq-event dev and increase
36 * the enable_count of devfreq-event dev.
37 * @edev : the devfreq-event device
38 *
39 * Note that this function increase the enable_count and enable the
40 * devfreq-event device. The devfreq-event device should be enabled before
41 * using it by devfreq device.
42 */
43int devfreq_event_enable_edev(struct devfreq_event_dev *edev)
44{
45 int ret = 0;
46
47 if (!edev || !edev->desc)
48 return -EINVAL;
49
50 mutex_lock(&edev->lock);
51 if (edev->desc->ops && edev->desc->ops->enable
52 && edev->enable_count == 0) {
53 ret = edev->desc->ops->enable(edev);
54 if (ret < 0)
55 goto err;
56 }
57 edev->enable_count++;
58err:
59 mutex_unlock(&edev->lock);
60
61 return ret;
62}
63EXPORT_SYMBOL_GPL(devfreq_event_enable_edev);
64
65/**
66 * devfreq_event_disable_edev() - Disable the devfreq-event dev and decrease
67 * the enable_count of the devfreq-event dev.
68 * @edev : the devfreq-event device
69 *
70 * Note that this function decrease the enable_count and disable the
71 * devfreq-event device. After the devfreq-event device is disabled,
72 * devfreq device can't use the devfreq-event device for get/set/reset
73 * operations.
74 */
75int devfreq_event_disable_edev(struct devfreq_event_dev *edev)
76{
77 int ret = 0;
78
79 if (!edev || !edev->desc)
80 return -EINVAL;
81
82 mutex_lock(&edev->lock);
83 if (edev->enable_count <= 0) {
84 dev_warn(&edev->dev, "unbalanced enable_count\n");
85 ret = -EIO;
86 goto err;
87 }
88
89 if (edev->desc->ops && edev->desc->ops->disable
90 && edev->enable_count == 1) {
91 ret = edev->desc->ops->disable(edev);
92 if (ret < 0)
93 goto err;
94 }
95 edev->enable_count--;
96err:
97 mutex_unlock(&edev->lock);
98
99 return ret;
100}
101EXPORT_SYMBOL_GPL(devfreq_event_disable_edev);
102
103/**
104 * devfreq_event_is_enabled() - Check whether devfreq-event dev is enabled or
105 * not.
106 * @edev : the devfreq-event device
107 *
108 * Note that this function check whether devfreq-event dev is enabled or not.
109 * If return true, the devfreq-event dev is enabeld. If return false, the
110 * devfreq-event dev is disabled.
111 */
112bool devfreq_event_is_enabled(struct devfreq_event_dev *edev)
113{
114 bool enabled = false;
115
116 if (!edev || !edev->desc)
117 return enabled;
118
119 mutex_lock(&edev->lock);
120
121 if (edev->enable_count > 0)
122 enabled = true;
123
124 mutex_unlock(&edev->lock);
125
126 return enabled;
127}
128EXPORT_SYMBOL_GPL(devfreq_event_is_enabled);
129
130/**
131 * devfreq_event_set_event() - Set event to devfreq-event dev to start.
132 * @edev : the devfreq-event device
133 *
134 * Note that this function set the event to the devfreq-event device to start
135 * for getting the event data which could be various event type.
136 */
137int devfreq_event_set_event(struct devfreq_event_dev *edev)
138{
139 int ret;
140
141 if (!edev || !edev->desc)
142 return -EINVAL;
143
144 if (!edev->desc->ops || !edev->desc->ops->set_event)
145 return -EINVAL;
146
147 if (!devfreq_event_is_enabled(edev))
148 return -EPERM;
149
150 mutex_lock(&edev->lock);
151 ret = edev->desc->ops->set_event(edev);
152 mutex_unlock(&edev->lock);
153
154 return ret;
155}
156EXPORT_SYMBOL_GPL(devfreq_event_set_event);
157
158/**
159 * devfreq_event_get_event() - Get {load|total}_count from devfreq-event dev.
160 * @edev : the devfreq-event device
161 * @edata : the calculated data of devfreq-event device
162 *
163 * Note that this function get the calculated event data from devfreq-event dev
164 * after stoping the progress of whole sequence of devfreq-event dev.
165 */
166int devfreq_event_get_event(struct devfreq_event_dev *edev,
167 struct devfreq_event_data *edata)
168{
169 int ret;
170
171 if (!edev || !edev->desc)
172 return -EINVAL;
173
174 if (!edev->desc->ops || !edev->desc->ops->get_event)
175 return -EINVAL;
176
177 if (!devfreq_event_is_enabled(edev))
178 return -EINVAL;
179
180 edata->total_count = edata->load_count = 0;
181
182 mutex_lock(&edev->lock);
183 ret = edev->desc->ops->get_event(edev, edata);
184 if (ret < 0)
185 edata->total_count = edata->load_count = 0;
186 mutex_unlock(&edev->lock);
187
188 return ret;
189}
190EXPORT_SYMBOL_GPL(devfreq_event_get_event);
191
192/**
193 * devfreq_event_reset_event() - Reset all opeations of devfreq-event dev.
194 * @edev : the devfreq-event device
195 *
196 * Note that this function stop all operations of devfreq-event dev and reset
197 * the current event data to make the devfreq-event device into initial state.
198 */
199int devfreq_event_reset_event(struct devfreq_event_dev *edev)
200{
201 int ret = 0;
202
203 if (!edev || !edev->desc)
204 return -EINVAL;
205
206 if (!devfreq_event_is_enabled(edev))
207 return -EPERM;
208
209 mutex_lock(&edev->lock);
210 if (edev->desc->ops && edev->desc->ops->reset)
211 ret = edev->desc->ops->reset(edev);
212 mutex_unlock(&edev->lock);
213
214 return ret;
215}
216EXPORT_SYMBOL_GPL(devfreq_event_reset_event);
217
218/**
219 * devfreq_event_get_edev_by_phandle() - Get the devfreq-event dev from
220 * devicetree.
221 * @dev : the pointer to the given device
222 * @phandle_name: name of property holding a phandle value
223 * @index : the index into list of devfreq-event device
224 *
225 * Note that this function return the pointer of devfreq-event device.
226 */
227struct devfreq_event_dev *devfreq_event_get_edev_by_phandle(struct device *dev,
228 const char *phandle_name, int index)
229{
230 struct device_node *node;
231 struct devfreq_event_dev *edev;
232
233 if (!dev->of_node || !phandle_name)
234 return ERR_PTR(-EINVAL);
235
236 node = of_parse_phandle(dev->of_node, phandle_name, index);
237 if (!node)
238 return ERR_PTR(-ENODEV);
239
240 mutex_lock(&devfreq_event_list_lock);
241 list_for_each_entry(edev, &devfreq_event_list, node) {
242 if (edev->dev.parent && device_match_of_node(edev->dev.parent, node))
243 goto out;
244 }
245
246 list_for_each_entry(edev, &devfreq_event_list, node) {
247 if (of_node_name_eq(node, edev->desc->name))
248 goto out;
249 }
250 edev = NULL;
251out:
252 mutex_unlock(&devfreq_event_list_lock);
253 of_node_put(node);
254 if (!edev)
255 return ERR_PTR(-ENODEV);
256
257 return edev;
258}
259EXPORT_SYMBOL_GPL(devfreq_event_get_edev_by_phandle);
260
261/**
262 * devfreq_event_get_edev_count() - Get the count of devfreq-event dev
263 * @dev : the pointer to the given device
264 * @phandle_name: name of property holding a phandle value
265 *
266 * Note that this function return the count of devfreq-event devices.
267 */
268int devfreq_event_get_edev_count(struct device *dev, const char *phandle_name)
269{
270 int count;
271
272 if (!dev->of_node || !phandle_name) {
273 dev_err(dev, "device does not have a device node entry\n");
274 return -EINVAL;
275 }
276
277 count = of_property_count_elems_of_size(dev->of_node, phandle_name,
278 sizeof(u32));
279 if (count < 0) {
280 dev_err(dev,
281 "failed to get the count of devfreq-event in %pOF node\n",
282 dev->of_node);
283 return count;
284 }
285
286 return count;
287}
288EXPORT_SYMBOL_GPL(devfreq_event_get_edev_count);
289
290static void devfreq_event_release_edev(struct device *dev)
291{
292 struct devfreq_event_dev *edev = to_devfreq_event(dev);
293
294 kfree(edev);
295}
296
297/**
298 * devfreq_event_add_edev() - Add new devfreq-event device.
299 * @dev : the device owning the devfreq-event device being created
300 * @desc : the devfreq-event device's descriptor which include essential
301 * data for devfreq-event device.
302 *
303 * Note that this function add new devfreq-event device to devfreq-event class
304 * list and register the device of the devfreq-event device.
305 */
306struct devfreq_event_dev *devfreq_event_add_edev(struct device *dev,
307 struct devfreq_event_desc *desc)
308{
309 struct devfreq_event_dev *edev;
310 static atomic_t event_no = ATOMIC_INIT(-1);
311 int ret;
312
313 if (!dev || !desc)
314 return ERR_PTR(-EINVAL);
315
316 if (!desc->name || !desc->ops)
317 return ERR_PTR(-EINVAL);
318
319 if (!desc->ops->set_event || !desc->ops->get_event)
320 return ERR_PTR(-EINVAL);
321
322 edev = kzalloc_obj(struct devfreq_event_dev);
323 if (!edev)
324 return ERR_PTR(-ENOMEM);
325
326 mutex_init(&edev->lock);
327 edev->desc = desc;
328 edev->enable_count = 0;
329 edev->dev.parent = dev;
330 edev->dev.class = &devfreq_event_class;
331 edev->dev.release = devfreq_event_release_edev;
332
333 dev_set_name(&edev->dev, "event%d", atomic_inc_return(&event_no));
334 ret = device_register(&edev->dev);
335 if (ret < 0) {
336 put_device(&edev->dev);
337 return ERR_PTR(ret);
338 }
339 dev_set_drvdata(&edev->dev, edev);
340
341 INIT_LIST_HEAD(&edev->node);
342
343 mutex_lock(&devfreq_event_list_lock);
344 list_add(&edev->node, &devfreq_event_list);
345 mutex_unlock(&devfreq_event_list_lock);
346
347 return edev;
348}
349EXPORT_SYMBOL_GPL(devfreq_event_add_edev);
350
351/**
352 * devfreq_event_remove_edev() - Remove the devfreq-event device registered.
353 * @edev : the devfreq-event device
354 *
355 * Note that this function removes the registered devfreq-event device.
356 */
357int devfreq_event_remove_edev(struct devfreq_event_dev *edev)
358{
359 if (!edev)
360 return -EINVAL;
361
362 WARN_ON(edev->enable_count);
363
364 mutex_lock(&devfreq_event_list_lock);
365 list_del(&edev->node);
366 mutex_unlock(&devfreq_event_list_lock);
367
368 device_unregister(&edev->dev);
369
370 return 0;
371}
372EXPORT_SYMBOL_GPL(devfreq_event_remove_edev);
373
374static int devm_devfreq_event_match(struct device *dev, void *res, void *data)
375{
376 struct devfreq_event_dev **r = res;
377
378 if (WARN_ON(!r || !*r))
379 return 0;
380
381 return *r == data;
382}
383
384static void devm_devfreq_event_release(struct device *dev, void *res)
385{
386 devfreq_event_remove_edev(*(struct devfreq_event_dev **)res);
387}
388
389/**
390 * devm_devfreq_event_add_edev() - Resource-managed devfreq_event_add_edev()
391 * @dev : the device owning the devfreq-event device being created
392 * @desc : the devfreq-event device's descriptor which include essential
393 * data for devfreq-event device.
394 *
395 * Note that this function manages automatically the memory of devfreq-event
396 * device using device resource management and simplify the free operation
397 * for memory of devfreq-event device.
398 */
399struct devfreq_event_dev *devm_devfreq_event_add_edev(struct device *dev,
400 struct devfreq_event_desc *desc)
401{
402 struct devfreq_event_dev **ptr, *edev;
403
404 ptr = devres_alloc(devm_devfreq_event_release, sizeof(*ptr),
405 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}
420EXPORT_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 */
430void 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}
436EXPORT_SYMBOL_GPL(devm_devfreq_event_remove_edev);
437
438/*
439 * Device attributes for devfreq-event class.
440 */
441static 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}
451static DEVICE_ATTR_RO(name);
452
453static 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}
463static DEVICE_ATTR_RO(enable_count);
464
465static struct attribute *devfreq_event_attrs[] = {
466 &dev_attr_name.attr,
467 &dev_attr_enable_count.attr,
468 NULL,
469};
470
471static int __init devfreq_event_init(void)
472{
473 int err;
474
475 err = class_register(&devfreq_event_class);
476 if (err)
477 pr_err("%s: couldn't create class\n", __FILE__);
478
479 return err;
480}
481subsys_initcall(devfreq_event_init);