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