3 * Copyright (c) 2013, Intel Corporation.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.
19 #include <linux/module.h>
20 #include <linux/device.h>
21 #include <linux/err.h>
22 #include <linux/slab.h>
23 #include <linux/powercap.h>
25 #define to_powercap_zone(n) container_of(n, struct powercap_zone, dev)
26 #define to_powercap_control_type(n) \
27 container_of(n, struct powercap_control_type, dev)
29 /* Power zone show function */
30 #define define_power_zone_show(_attr) \
31 static ssize_t _attr##_show(struct device *dev, \
32 struct device_attribute *dev_attr,\
36 ssize_t len = -EINVAL; \
37 struct powercap_zone *power_zone = to_powercap_zone(dev); \
39 if (power_zone->ops->get_##_attr) { \
40 if (!power_zone->ops->get_##_attr(power_zone, &value)) \
41 len = sprintf(buf, "%lld\n", value); \
47 /* The only meaningful input is 0 (reset), others are silently ignored */
48 #define define_power_zone_store(_attr) \
49 static ssize_t _attr##_store(struct device *dev,\
50 struct device_attribute *dev_attr, \
51 const char *buf, size_t count) \
54 struct powercap_zone *power_zone = to_powercap_zone(dev); \
57 err = kstrtoull(buf, 10, &value); \
62 if (power_zone->ops->reset_##_attr) { \
63 if (!power_zone->ops->reset_##_attr(power_zone)) \
70 /* Power zone constraint show function */
71 #define define_power_zone_constraint_show(_attr) \
72 static ssize_t show_constraint_##_attr(struct device *dev, \
73 struct device_attribute *dev_attr,\
77 ssize_t len = -ENODATA; \
78 struct powercap_zone *power_zone = to_powercap_zone(dev); \
80 struct powercap_zone_constraint *pconst;\
82 if (!sscanf(dev_attr->attr.name, "constraint_%d_", &id)) \
84 if (id >= power_zone->const_id_cnt) \
86 pconst = &power_zone->constraints[id]; \
87 if (pconst && pconst->ops && pconst->ops->get_##_attr) { \
88 if (!pconst->ops->get_##_attr(power_zone, id, &value)) \
89 len = sprintf(buf, "%lld\n", value); \
95 /* Power zone constraint store function */
96 #define define_power_zone_constraint_store(_attr) \
97 static ssize_t store_constraint_##_attr(struct device *dev,\
98 struct device_attribute *dev_attr, \
99 const char *buf, size_t count) \
103 struct powercap_zone *power_zone = to_powercap_zone(dev); \
105 struct powercap_zone_constraint *pconst;\
107 if (!sscanf(dev_attr->attr.name, "constraint_%d_", &id)) \
109 if (id >= power_zone->const_id_cnt) \
111 pconst = &power_zone->constraints[id]; \
112 err = kstrtoull(buf, 10, &value); \
115 if (pconst && pconst->ops && pconst->ops->set_##_attr) { \
116 if (!pconst->ops->set_##_attr(power_zone, id, value)) \
123 /* Power zone information callbacks */
124 define_power_zone_show(power_uw);
125 define_power_zone_show(max_power_range_uw);
126 define_power_zone_show(energy_uj);
127 define_power_zone_store(energy_uj);
128 define_power_zone_show(max_energy_range_uj);
130 /* Power zone attributes */
131 static DEVICE_ATTR_RO(max_power_range_uw);
132 static DEVICE_ATTR_RO(power_uw);
133 static DEVICE_ATTR_RO(max_energy_range_uj);
134 static DEVICE_ATTR_RW(energy_uj);
136 /* Power zone constraint attributes callbacks */
137 define_power_zone_constraint_show(power_limit_uw);
138 define_power_zone_constraint_store(power_limit_uw);
139 define_power_zone_constraint_show(time_window_us);
140 define_power_zone_constraint_store(time_window_us);
141 define_power_zone_constraint_show(max_power_uw);
142 define_power_zone_constraint_show(min_power_uw);
143 define_power_zone_constraint_show(max_time_window_us);
144 define_power_zone_constraint_show(min_time_window_us);
146 /* For one time seeding of constraint device attributes */
147 struct powercap_constraint_attr {
148 struct device_attribute power_limit_attr;
149 struct device_attribute time_window_attr;
150 struct device_attribute max_power_attr;
151 struct device_attribute min_power_attr;
152 struct device_attribute max_time_window_attr;
153 struct device_attribute min_time_window_attr;
154 struct device_attribute name_attr;
157 static struct powercap_constraint_attr
158 constraint_attrs[MAX_CONSTRAINTS_PER_ZONE];
160 /* A list of powercap control_types */
161 static LIST_HEAD(powercap_cntrl_list);
162 /* Mutex to protect list of powercap control_types */
163 static DEFINE_MUTEX(powercap_cntrl_list_lock);
165 #define POWERCAP_CONSTRAINT_NAME_LEN 30 /* Some limit to avoid overflow */
166 static ssize_t show_constraint_name(struct device *dev,
167 struct device_attribute *dev_attr,
171 struct powercap_zone *power_zone = to_powercap_zone(dev);
173 ssize_t len = -ENODATA;
174 struct powercap_zone_constraint *pconst;
176 if (!sscanf(dev_attr->attr.name, "constraint_%d_", &id))
178 if (id >= power_zone->const_id_cnt)
180 pconst = &power_zone->constraints[id];
182 if (pconst && pconst->ops && pconst->ops->get_name) {
183 name = pconst->ops->get_name(power_zone, id);
185 snprintf(buf, POWERCAP_CONSTRAINT_NAME_LEN,
187 buf[POWERCAP_CONSTRAINT_NAME_LEN] = '\0';
195 static int create_constraint_attribute(int id, const char *name,
197 struct device_attribute *dev_attr,
198 ssize_t (*show)(struct device *,
199 struct device_attribute *, char *),
200 ssize_t (*store)(struct device *,
201 struct device_attribute *,
202 const char *, size_t)
206 dev_attr->attr.name = kasprintf(GFP_KERNEL, "constraint_%d_%s",
208 if (!dev_attr->attr.name)
210 dev_attr->attr.mode = mode;
211 dev_attr->show = show;
212 dev_attr->store = store;
217 static void free_constraint_attributes(void)
221 for (i = 0; i < MAX_CONSTRAINTS_PER_ZONE; ++i) {
222 kfree(constraint_attrs[i].power_limit_attr.attr.name);
223 kfree(constraint_attrs[i].time_window_attr.attr.name);
224 kfree(constraint_attrs[i].name_attr.attr.name);
225 kfree(constraint_attrs[i].max_power_attr.attr.name);
226 kfree(constraint_attrs[i].min_power_attr.attr.name);
227 kfree(constraint_attrs[i].max_time_window_attr.attr.name);
228 kfree(constraint_attrs[i].min_time_window_attr.attr.name);
232 static int seed_constraint_attributes(void)
237 for (i = 0; i < MAX_CONSTRAINTS_PER_ZONE; ++i) {
238 ret = create_constraint_attribute(i, "power_limit_uw",
240 &constraint_attrs[i].power_limit_attr,
241 show_constraint_power_limit_uw,
242 store_constraint_power_limit_uw);
245 ret = create_constraint_attribute(i, "time_window_us",
247 &constraint_attrs[i].time_window_attr,
248 show_constraint_time_window_us,
249 store_constraint_time_window_us);
252 ret = create_constraint_attribute(i, "name", S_IRUGO,
253 &constraint_attrs[i].name_attr,
254 show_constraint_name,
258 ret = create_constraint_attribute(i, "max_power_uw", S_IRUGO,
259 &constraint_attrs[i].max_power_attr,
260 show_constraint_max_power_uw,
264 ret = create_constraint_attribute(i, "min_power_uw", S_IRUGO,
265 &constraint_attrs[i].min_power_attr,
266 show_constraint_min_power_uw,
270 ret = create_constraint_attribute(i, "max_time_window_us",
272 &constraint_attrs[i].max_time_window_attr,
273 show_constraint_max_time_window_us,
277 ret = create_constraint_attribute(i, "min_time_window_us",
279 &constraint_attrs[i].min_time_window_attr,
280 show_constraint_min_time_window_us,
290 free_constraint_attributes();
295 static int create_constraints(struct powercap_zone *power_zone,
297 struct powercap_zone_constraint_ops *const_ops)
302 struct powercap_zone_constraint *pconst;
304 if (!power_zone || !const_ops || !const_ops->get_power_limit_uw ||
305 !const_ops->set_power_limit_uw ||
306 !const_ops->get_time_window_us ||
307 !const_ops->set_time_window_us)
310 count = power_zone->zone_attr_count;
311 for (i = 0; i < nr_constraints; ++i) {
312 pconst = &power_zone->constraints[i];
313 pconst->ops = const_ops;
314 pconst->id = power_zone->const_id_cnt;
315 power_zone->const_id_cnt++;
316 power_zone->zone_dev_attrs[count++] =
317 &constraint_attrs[i].power_limit_attr.attr;
318 power_zone->zone_dev_attrs[count++] =
319 &constraint_attrs[i].time_window_attr.attr;
320 if (pconst->ops->get_name)
321 power_zone->zone_dev_attrs[count++] =
322 &constraint_attrs[i].name_attr.attr;
323 if (pconst->ops->get_max_power_uw)
324 power_zone->zone_dev_attrs[count++] =
325 &constraint_attrs[i].max_power_attr.attr;
326 if (pconst->ops->get_min_power_uw)
327 power_zone->zone_dev_attrs[count++] =
328 &constraint_attrs[i].min_power_attr.attr;
329 if (pconst->ops->get_max_time_window_us)
330 power_zone->zone_dev_attrs[count++] =
331 &constraint_attrs[i].max_time_window_attr.attr;
332 if (pconst->ops->get_min_time_window_us)
333 power_zone->zone_dev_attrs[count++] =
334 &constraint_attrs[i].min_time_window_attr.attr;
336 power_zone->zone_attr_count = count;
341 static bool control_type_valid(void *control_type)
343 struct powercap_control_type *pos = NULL;
346 mutex_lock(&powercap_cntrl_list_lock);
348 list_for_each_entry(pos, &powercap_cntrl_list, node) {
349 if (pos == control_type) {
354 mutex_unlock(&powercap_cntrl_list_lock);
359 static ssize_t name_show(struct device *dev,
360 struct device_attribute *attr,
363 struct powercap_zone *power_zone = to_powercap_zone(dev);
365 return sprintf(buf, "%s\n", power_zone->name);
368 static DEVICE_ATTR_RO(name);
370 /* Create zone and attributes in sysfs */
371 static void create_power_zone_common_attributes(
372 struct powercap_zone *power_zone)
376 power_zone->zone_dev_attrs[count++] = &dev_attr_name.attr;
377 if (power_zone->ops->get_max_energy_range_uj)
378 power_zone->zone_dev_attrs[count++] =
379 &dev_attr_max_energy_range_uj.attr;
380 if (power_zone->ops->get_energy_uj)
381 power_zone->zone_dev_attrs[count++] =
382 &dev_attr_energy_uj.attr;
383 if (power_zone->ops->get_power_uw)
384 power_zone->zone_dev_attrs[count++] =
385 &dev_attr_power_uw.attr;
386 if (power_zone->ops->get_max_power_range_uw)
387 power_zone->zone_dev_attrs[count++] =
388 &dev_attr_max_power_range_uw.attr;
389 power_zone->zone_dev_attrs[count] = NULL;
390 power_zone->zone_attr_count = count;
393 static void powercap_release(struct device *dev)
398 struct powercap_zone *power_zone = to_powercap_zone(dev);
400 /* Store flag as the release() may free memory */
401 allocated = power_zone->allocated;
402 /* Remove id from parent idr struct */
403 idr_remove(power_zone->parent_idr, power_zone->id);
404 /* Destroy idrs allocated for this zone */
405 idr_destroy(&power_zone->idr);
406 kfree(power_zone->name);
407 kfree(power_zone->zone_dev_attrs);
408 kfree(power_zone->constraints);
409 if (power_zone->ops->release)
410 power_zone->ops->release(power_zone);
414 struct powercap_control_type *control_type =
415 to_powercap_control_type(dev);
417 /* Store flag as the release() may free memory */
418 allocated = control_type->allocated;
419 idr_destroy(&control_type->idr);
420 mutex_destroy(&control_type->lock);
421 if (control_type->ops && control_type->ops->release)
422 control_type->ops->release(control_type);
428 static ssize_t enabled_show(struct device *dev,
429 struct device_attribute *attr,
434 /* Default is enabled */
436 struct powercap_zone *power_zone = to_powercap_zone(dev);
437 if (power_zone->ops->get_enable)
438 if (power_zone->ops->get_enable(power_zone, &mode))
441 struct powercap_control_type *control_type =
442 to_powercap_control_type(dev);
443 if (control_type->ops && control_type->ops->get_enable)
444 if (control_type->ops->get_enable(control_type, &mode))
448 return sprintf(buf, "%d\n", mode);
451 static ssize_t enabled_store(struct device *dev,
452 struct device_attribute *attr,
453 const char *buf, size_t len)
457 if (strtobool(buf, &mode))
460 struct powercap_zone *power_zone = to_powercap_zone(dev);
461 if (power_zone->ops->set_enable)
462 if (!power_zone->ops->set_enable(power_zone, mode))
465 struct powercap_control_type *control_type =
466 to_powercap_control_type(dev);
467 if (control_type->ops && control_type->ops->set_enable)
468 if (!control_type->ops->set_enable(control_type, mode))
475 static DEVICE_ATTR_RW(enabled);
477 static struct attribute *powercap_attrs[] = {
478 &dev_attr_enabled.attr,
481 ATTRIBUTE_GROUPS(powercap);
483 static struct class powercap_class = {
485 .dev_release = powercap_release,
486 .dev_groups = powercap_groups,
489 struct powercap_zone *powercap_register_zone(
490 struct powercap_zone *power_zone,
491 struct powercap_control_type *control_type,
493 struct powercap_zone *parent,
494 const struct powercap_zone_ops *ops,
496 struct powercap_zone_constraint_ops *const_ops)
501 if (!name || !control_type || !ops ||
502 nr_constraints > MAX_CONSTRAINTS_PER_ZONE ||
503 (!ops->get_energy_uj && !ops->get_power_uw) ||
504 !control_type_valid(control_type))
505 return ERR_PTR(-EINVAL);
509 return ERR_PTR(-EINVAL);
510 memset(power_zone, 0, sizeof(*power_zone));
512 power_zone = kzalloc(sizeof(*power_zone), GFP_KERNEL);
514 return ERR_PTR(-ENOMEM);
515 power_zone->allocated = true;
517 power_zone->ops = ops;
518 power_zone->control_type_inst = control_type;
520 power_zone->dev.parent = &control_type->dev;
521 power_zone->parent_idr = &control_type->idr;
523 power_zone->dev.parent = &parent->dev;
524 power_zone->parent_idr = &parent->idr;
526 power_zone->dev.class = &powercap_class;
528 mutex_lock(&control_type->lock);
529 /* Using idr to get the unique id */
530 result = idr_alloc(power_zone->parent_idr, NULL, 0, 0, GFP_KERNEL);
534 power_zone->id = result;
535 idr_init(&power_zone->idr);
536 power_zone->name = kstrdup(name, GFP_KERNEL);
537 if (!power_zone->name)
539 dev_set_name(&power_zone->dev, "%s:%x",
540 dev_name(power_zone->dev.parent),
542 power_zone->constraints = kzalloc(sizeof(*power_zone->constraints) *
543 nr_constraints, GFP_KERNEL);
544 if (!power_zone->constraints)
545 goto err_const_alloc;
547 nr_attrs = nr_constraints * POWERCAP_CONSTRAINTS_ATTRS +
548 POWERCAP_ZONE_MAX_ATTRS + 1;
549 power_zone->zone_dev_attrs = kzalloc(sizeof(void *) *
550 nr_attrs, GFP_KERNEL);
551 if (!power_zone->zone_dev_attrs)
553 create_power_zone_common_attributes(power_zone);
554 result = create_constraints(power_zone, nr_constraints, const_ops);
558 power_zone->zone_dev_attrs[power_zone->zone_attr_count] = NULL;
559 power_zone->dev_zone_attr_group.attrs = power_zone->zone_dev_attrs;
560 power_zone->dev_attr_groups[0] = &power_zone->dev_zone_attr_group;
561 power_zone->dev_attr_groups[1] = NULL;
562 power_zone->dev.groups = power_zone->dev_attr_groups;
563 result = device_register(&power_zone->dev);
567 control_type->nr_zones++;
568 mutex_unlock(&control_type->lock);
573 kfree(power_zone->zone_dev_attrs);
575 kfree(power_zone->constraints);
577 kfree(power_zone->name);
579 idr_remove(power_zone->parent_idr, power_zone->id);
581 if (power_zone->allocated)
583 mutex_unlock(&control_type->lock);
585 return ERR_PTR(result);
587 EXPORT_SYMBOL_GPL(powercap_register_zone);
589 int powercap_unregister_zone(struct powercap_control_type *control_type,
590 struct powercap_zone *power_zone)
592 if (!power_zone || !control_type)
595 mutex_lock(&control_type->lock);
596 control_type->nr_zones--;
597 mutex_unlock(&control_type->lock);
599 device_unregister(&power_zone->dev);
603 EXPORT_SYMBOL_GPL(powercap_unregister_zone);
605 struct powercap_control_type *powercap_register_control_type(
606 struct powercap_control_type *control_type,
608 const struct powercap_control_type_ops *ops)
613 return ERR_PTR(-EINVAL);
615 if (!ops || !ops->release)
616 return ERR_PTR(-EINVAL);
617 memset(control_type, 0, sizeof(*control_type));
619 control_type = kzalloc(sizeof(*control_type), GFP_KERNEL);
621 return ERR_PTR(-ENOMEM);
622 control_type->allocated = true;
624 mutex_init(&control_type->lock);
625 control_type->ops = ops;
626 INIT_LIST_HEAD(&control_type->node);
627 control_type->dev.class = &powercap_class;
628 dev_set_name(&control_type->dev, name);
629 result = device_register(&control_type->dev);
631 if (control_type->allocated)
633 return ERR_PTR(result);
635 idr_init(&control_type->idr);
637 mutex_lock(&powercap_cntrl_list_lock);
638 list_add_tail(&control_type->node, &powercap_cntrl_list);
639 mutex_unlock(&powercap_cntrl_list_lock);
643 EXPORT_SYMBOL_GPL(powercap_register_control_type);
645 int powercap_unregister_control_type(struct powercap_control_type *control_type)
647 struct powercap_control_type *pos = NULL;
649 if (control_type->nr_zones) {
650 dev_err(&control_type->dev, "Zones of this type still not freed\n");
653 mutex_lock(&powercap_cntrl_list_lock);
654 list_for_each_entry(pos, &powercap_cntrl_list, node) {
655 if (pos == control_type) {
656 list_del(&control_type->node);
657 mutex_unlock(&powercap_cntrl_list_lock);
658 device_unregister(&control_type->dev);
662 mutex_unlock(&powercap_cntrl_list_lock);
666 EXPORT_SYMBOL_GPL(powercap_unregister_control_type);
668 static int __init powercap_init(void)
672 result = seed_constraint_attributes();
676 result = class_register(&powercap_class);
681 device_initcall(powercap_init);
683 MODULE_DESCRIPTION("PowerCap sysfs Driver");
684 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
685 MODULE_LICENSE("GPL v2");