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(lock: &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(lock: &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(lock: &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(lock: &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(lock: &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(lock: &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(error: -EINVAL); |
229 | |
230 | node = of_parse_phandle(np: dev->of_node, phandle_name, index); |
231 | if (!node) |
232 | return ERR_PTR(error: -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(dev: edev->dev.parent, np: node)) |
237 | goto out; |
238 | } |
239 | |
240 | list_for_each_entry(edev, &devfreq_event_list, node) { |
241 | if (of_node_name_eq(np: node, name: edev->desc->name)) |
242 | goto out; |
243 | } |
244 | edev = NULL; |
245 | out: |
246 | mutex_unlock(lock: &devfreq_event_list_lock); |
247 | |
248 | if (!edev) { |
249 | of_node_put(node); |
250 | return ERR_PTR(error: -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(np: dev->of_node, propname: phandle_name, |
276 | elem_size: 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(objp: 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(error: -EINVAL); |
313 | |
314 | if (!desc->name || !desc->ops) |
315 | return ERR_PTR(error: -EINVAL); |
316 | |
317 | if (!desc->ops->set_event || !desc->ops->get_event) |
318 | return ERR_PTR(error: -EINVAL); |
319 | |
320 | edev = kzalloc(size: sizeof(struct devfreq_event_dev), GFP_KERNEL); |
321 | if (!edev) |
322 | return ERR_PTR(error: -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(dev: &edev->dev, name: "event%d" , atomic_inc_return(v: &event_no)); |
332 | ret = device_register(dev: &edev->dev); |
333 | if (ret < 0) { |
334 | put_device(dev: &edev->dev); |
335 | return ERR_PTR(error: ret); |
336 | } |
337 | dev_set_drvdata(dev: &edev->dev, data: edev); |
338 | |
339 | INIT_LIST_HEAD(list: &edev->node); |
340 | |
341 | mutex_lock(&devfreq_event_list_lock); |
342 | list_add(new: &edev->node, head: &devfreq_event_list); |
343 | mutex_unlock(lock: &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(entry: &edev->node); |
364 | mutex_unlock(lock: &devfreq_event_list_lock); |
365 | |
366 | device_unregister(dev: &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(error: -ENOMEM); |
406 | |
407 | edev = devfreq_event_add_edev(dev, desc); |
408 | if (IS_ERR(ptr: edev)) { |
409 | devres_free(res: ptr); |
410 | return ERR_PTR(error: -ENOMEM); |
411 | } |
412 | |
413 | *ptr = edev; |
414 | devres_add(dev, res: 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, fmt: "%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, fmt: "%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(name: "devfreq-event" ); |
473 | if (IS_ERR(ptr: devfreq_event_class)) { |
474 | pr_err("%s: couldn't create class\n" , __FILE__); |
475 | return PTR_ERR(ptr: 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 | |