1/* 2 * Power capping class 3 * Copyright (c) 2013, Intel Corporation. 4 * 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. 8 * 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 12 * more details. 13 * 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. 16 * 17 */ 18 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> 24 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) 28 29/* Power zone show function */ 30#define define_power_zone_show(_attr) \ 31static ssize_t _attr##_show(struct device *dev, \ 32 struct device_attribute *dev_attr,\ 33 char *buf) \ 34{ \ 35 u64 value; \ 36 ssize_t len = -EINVAL; \ 37 struct powercap_zone *power_zone = to_powercap_zone(dev); \ 38 \ 39 if (power_zone->ops->get_##_attr) { \ 40 if (!power_zone->ops->get_##_attr(power_zone, &value)) \ 41 len = sprintf(buf, "%lld\n", value); \ 42 } \ 43 \ 44 return len; \ 45} 46 47/* The only meaningful input is 0 (reset), others are silently ignored */ 48#define define_power_zone_store(_attr) \ 49static ssize_t _attr##_store(struct device *dev,\ 50 struct device_attribute *dev_attr, \ 51 const char *buf, size_t count) \ 52{ \ 53 int err; \ 54 struct powercap_zone *power_zone = to_powercap_zone(dev); \ 55 u64 value; \ 56 \ 57 err = kstrtoull(buf, 10, &value); \ 58 if (err) \ 59 return -EINVAL; \ 60 if (value) \ 61 return count; \ 62 if (power_zone->ops->reset_##_attr) { \ 63 if (!power_zone->ops->reset_##_attr(power_zone)) \ 64 return count; \ 65 } \ 66 \ 67 return -EINVAL; \ 68} 69 70/* Power zone constraint show function */ 71#define define_power_zone_constraint_show(_attr) \ 72static ssize_t show_constraint_##_attr(struct device *dev, \ 73 struct device_attribute *dev_attr,\ 74 char *buf) \ 75{ \ 76 u64 value; \ 77 ssize_t len = -ENODATA; \ 78 struct powercap_zone *power_zone = to_powercap_zone(dev); \ 79 int id; \ 80 struct powercap_zone_constraint *pconst;\ 81 \ 82 if (!sscanf(dev_attr->attr.name, "constraint_%d_", &id)) \ 83 return -EINVAL; \ 84 if (id >= power_zone->const_id_cnt) \ 85 return -EINVAL; \ 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); \ 90 } \ 91 \ 92 return len; \ 93} 94 95/* Power zone constraint store function */ 96#define define_power_zone_constraint_store(_attr) \ 97static ssize_t store_constraint_##_attr(struct device *dev,\ 98 struct device_attribute *dev_attr, \ 99 const char *buf, size_t count) \ 100{ \ 101 int err; \ 102 u64 value; \ 103 struct powercap_zone *power_zone = to_powercap_zone(dev); \ 104 int id; \ 105 struct powercap_zone_constraint *pconst;\ 106 \ 107 if (!sscanf(dev_attr->attr.name, "constraint_%d_", &id)) \ 108 return -EINVAL; \ 109 if (id >= power_zone->const_id_cnt) \ 110 return -EINVAL; \ 111 pconst = &power_zone->constraints[id]; \ 112 err = kstrtoull(buf, 10, &value); \ 113 if (err) \ 114 return -EINVAL; \ 115 if (pconst && pconst->ops && pconst->ops->set_##_attr) { \ 116 if (!pconst->ops->set_##_attr(power_zone, id, value)) \ 117 return count; \ 118 } \ 119 \ 120 return -ENODATA; \ 121} 122 123/* Power zone information callbacks */ 124define_power_zone_show(power_uw); 125define_power_zone_show(max_power_range_uw); 126define_power_zone_show(energy_uj); 127define_power_zone_store(energy_uj); 128define_power_zone_show(max_energy_range_uj); 129 130/* Power zone attributes */ 131static DEVICE_ATTR_RO(max_power_range_uw); 132static DEVICE_ATTR_RO(power_uw); 133static DEVICE_ATTR_RO(max_energy_range_uj); 134static DEVICE_ATTR_RW(energy_uj); 135 136/* Power zone constraint attributes callbacks */ 137define_power_zone_constraint_show(power_limit_uw); 138define_power_zone_constraint_store(power_limit_uw); 139define_power_zone_constraint_show(time_window_us); 140define_power_zone_constraint_store(time_window_us); 141define_power_zone_constraint_show(max_power_uw); 142define_power_zone_constraint_show(min_power_uw); 143define_power_zone_constraint_show(max_time_window_us); 144define_power_zone_constraint_show(min_time_window_us); 145 146/* For one time seeding of constraint device attributes */ 147struct 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; 155}; 156 157static struct powercap_constraint_attr 158 constraint_attrs[MAX_CONSTRAINTS_PER_ZONE]; 159 160/* A list of powercap control_types */ 161static LIST_HEAD(powercap_cntrl_list); 162/* Mutex to protect list of powercap control_types */ 163static DEFINE_MUTEX(powercap_cntrl_list_lock); 164 165#define POWERCAP_CONSTRAINT_NAME_LEN 30 /* Some limit to avoid overflow */ 166static ssize_t show_constraint_name(struct device *dev, 167 struct device_attribute *dev_attr, 168 char *buf) 169{ 170 const char *name; 171 struct powercap_zone *power_zone = to_powercap_zone(dev); 172 int id; 173 ssize_t len = -ENODATA; 174 struct powercap_zone_constraint *pconst; 175 176 if (!sscanf(dev_attr->attr.name, "constraint_%d_", &id)) 177 return -EINVAL; 178 if (id >= power_zone->const_id_cnt) 179 return -EINVAL; 180 pconst = &power_zone->constraints[id]; 181 182 if (pconst && pconst->ops && pconst->ops->get_name) { 183 name = pconst->ops->get_name(power_zone, id); 184 if (name) { 185 snprintf(buf, POWERCAP_CONSTRAINT_NAME_LEN, 186 "%s\n", name); 187 buf[POWERCAP_CONSTRAINT_NAME_LEN] = '\0'; 188 len = strlen(buf); 189 } 190 } 191 192 return len; 193} 194 195static int create_constraint_attribute(int id, const char *name, 196 int mode, 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) 203 ) 204{ 205 206 dev_attr->attr.name = kasprintf(GFP_KERNEL, "constraint_%d_%s", 207 id, name); 208 if (!dev_attr->attr.name) 209 return -ENOMEM; 210 dev_attr->attr.mode = mode; 211 dev_attr->show = show; 212 dev_attr->store = store; 213 214 return 0; 215} 216 217static void free_constraint_attributes(void) 218{ 219 int i; 220 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); 229 } 230} 231 232static int seed_constraint_attributes(void) 233{ 234 int i; 235 int ret; 236 237 for (i = 0; i < MAX_CONSTRAINTS_PER_ZONE; ++i) { 238 ret = create_constraint_attribute(i, "power_limit_uw", 239 S_IWUSR | S_IRUGO, 240 &constraint_attrs[i].power_limit_attr, 241 show_constraint_power_limit_uw, 242 store_constraint_power_limit_uw); 243 if (ret) 244 goto err_alloc; 245 ret = create_constraint_attribute(i, "time_window_us", 246 S_IWUSR | S_IRUGO, 247 &constraint_attrs[i].time_window_attr, 248 show_constraint_time_window_us, 249 store_constraint_time_window_us); 250 if (ret) 251 goto err_alloc; 252 ret = create_constraint_attribute(i, "name", S_IRUGO, 253 &constraint_attrs[i].name_attr, 254 show_constraint_name, 255 NULL); 256 if (ret) 257 goto err_alloc; 258 ret = create_constraint_attribute(i, "max_power_uw", S_IRUGO, 259 &constraint_attrs[i].max_power_attr, 260 show_constraint_max_power_uw, 261 NULL); 262 if (ret) 263 goto err_alloc; 264 ret = create_constraint_attribute(i, "min_power_uw", S_IRUGO, 265 &constraint_attrs[i].min_power_attr, 266 show_constraint_min_power_uw, 267 NULL); 268 if (ret) 269 goto err_alloc; 270 ret = create_constraint_attribute(i, "max_time_window_us", 271 S_IRUGO, 272 &constraint_attrs[i].max_time_window_attr, 273 show_constraint_max_time_window_us, 274 NULL); 275 if (ret) 276 goto err_alloc; 277 ret = create_constraint_attribute(i, "min_time_window_us", 278 S_IRUGO, 279 &constraint_attrs[i].min_time_window_attr, 280 show_constraint_min_time_window_us, 281 NULL); 282 if (ret) 283 goto err_alloc; 284 285 } 286 287 return 0; 288 289err_alloc: 290 free_constraint_attributes(); 291 292 return ret; 293} 294 295static int create_constraints(struct powercap_zone *power_zone, 296 int nr_constraints, 297 struct powercap_zone_constraint_ops *const_ops) 298{ 299 int i; 300 int ret = 0; 301 int count; 302 struct powercap_zone_constraint *pconst; 303 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) 308 return -EINVAL; 309 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; 335 } 336 power_zone->zone_attr_count = count; 337 338 return ret; 339} 340 341static bool control_type_valid(void *control_type) 342{ 343 struct powercap_control_type *pos = NULL; 344 bool found = false; 345 346 mutex_lock(&powercap_cntrl_list_lock); 347 348 list_for_each_entry(pos, &powercap_cntrl_list, node) { 349 if (pos == control_type) { 350 found = true; 351 break; 352 } 353 } 354 mutex_unlock(&powercap_cntrl_list_lock); 355 356 return found; 357} 358 359static ssize_t name_show(struct device *dev, 360 struct device_attribute *attr, 361 char *buf) 362{ 363 struct powercap_zone *power_zone = to_powercap_zone(dev); 364 365 return sprintf(buf, "%s\n", power_zone->name); 366} 367 368static DEVICE_ATTR_RO(name); 369 370/* Create zone and attributes in sysfs */ 371static void create_power_zone_common_attributes( 372 struct powercap_zone *power_zone) 373{ 374 int count = 0; 375 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 if (power_zone->ops->reset_energy_uj) 382 dev_attr_energy_uj.attr.mode = S_IWUSR | S_IRUGO; 383 else 384 dev_attr_energy_uj.attr.mode = S_IRUGO; 385 power_zone->zone_dev_attrs[count++] = 386 &dev_attr_energy_uj.attr; 387 } 388 if (power_zone->ops->get_power_uw) 389 power_zone->zone_dev_attrs[count++] = 390 &dev_attr_power_uw.attr; 391 if (power_zone->ops->get_max_power_range_uw) 392 power_zone->zone_dev_attrs[count++] = 393 &dev_attr_max_power_range_uw.attr; 394 power_zone->zone_dev_attrs[count] = NULL; 395 power_zone->zone_attr_count = count; 396} 397 398static void powercap_release(struct device *dev) 399{ 400 bool allocated; 401 402 if (dev->parent) { 403 struct powercap_zone *power_zone = to_powercap_zone(dev); 404 405 /* Store flag as the release() may free memory */ 406 allocated = power_zone->allocated; 407 /* Remove id from parent idr struct */ 408 idr_remove(power_zone->parent_idr, power_zone->id); 409 /* Destroy idrs allocated for this zone */ 410 idr_destroy(&power_zone->idr); 411 kfree(power_zone->name); 412 kfree(power_zone->zone_dev_attrs); 413 kfree(power_zone->constraints); 414 if (power_zone->ops->release) 415 power_zone->ops->release(power_zone); 416 if (allocated) 417 kfree(power_zone); 418 } else { 419 struct powercap_control_type *control_type = 420 to_powercap_control_type(dev); 421 422 /* Store flag as the release() may free memory */ 423 allocated = control_type->allocated; 424 idr_destroy(&control_type->idr); 425 mutex_destroy(&control_type->lock); 426 if (control_type->ops && control_type->ops->release) 427 control_type->ops->release(control_type); 428 if (allocated) 429 kfree(control_type); 430 } 431} 432 433static ssize_t enabled_show(struct device *dev, 434 struct device_attribute *attr, 435 char *buf) 436{ 437 bool mode = true; 438 439 /* Default is enabled */ 440 if (dev->parent) { 441 struct powercap_zone *power_zone = to_powercap_zone(dev); 442 if (power_zone->ops->get_enable) 443 if (power_zone->ops->get_enable(power_zone, &mode)) 444 mode = false; 445 } else { 446 struct powercap_control_type *control_type = 447 to_powercap_control_type(dev); 448 if (control_type->ops && control_type->ops->get_enable) 449 if (control_type->ops->get_enable(control_type, &mode)) 450 mode = false; 451 } 452 453 return sprintf(buf, "%d\n", mode); 454} 455 456static ssize_t enabled_store(struct device *dev, 457 struct device_attribute *attr, 458 const char *buf, size_t len) 459{ 460 bool mode; 461 462 if (strtobool(buf, &mode)) 463 return -EINVAL; 464 if (dev->parent) { 465 struct powercap_zone *power_zone = to_powercap_zone(dev); 466 if (power_zone->ops->set_enable) 467 if (!power_zone->ops->set_enable(power_zone, mode)) 468 return len; 469 } else { 470 struct powercap_control_type *control_type = 471 to_powercap_control_type(dev); 472 if (control_type->ops && control_type->ops->set_enable) 473 if (!control_type->ops->set_enable(control_type, mode)) 474 return len; 475 } 476 477 return -ENOSYS; 478} 479 480static DEVICE_ATTR_RW(enabled); 481 482static struct attribute *powercap_attrs[] = { 483 &dev_attr_enabled.attr, 484 NULL, 485}; 486ATTRIBUTE_GROUPS(powercap); 487 488static struct class powercap_class = { 489 .name = "powercap", 490 .dev_release = powercap_release, 491 .dev_groups = powercap_groups, 492}; 493 494struct powercap_zone *powercap_register_zone( 495 struct powercap_zone *power_zone, 496 struct powercap_control_type *control_type, 497 const char *name, 498 struct powercap_zone *parent, 499 const struct powercap_zone_ops *ops, 500 int nr_constraints, 501 struct powercap_zone_constraint_ops *const_ops) 502{ 503 int result; 504 int nr_attrs; 505 506 if (!name || !control_type || !ops || 507 nr_constraints > MAX_CONSTRAINTS_PER_ZONE || 508 (!ops->get_energy_uj && !ops->get_power_uw) || 509 !control_type_valid(control_type)) 510 return ERR_PTR(-EINVAL); 511 512 if (power_zone) { 513 if (!ops->release) 514 return ERR_PTR(-EINVAL); 515 memset(power_zone, 0, sizeof(*power_zone)); 516 } else { 517 power_zone = kzalloc(sizeof(*power_zone), GFP_KERNEL); 518 if (!power_zone) 519 return ERR_PTR(-ENOMEM); 520 power_zone->allocated = true; 521 } 522 power_zone->ops = ops; 523 power_zone->control_type_inst = control_type; 524 if (!parent) { 525 power_zone->dev.parent = &control_type->dev; 526 power_zone->parent_idr = &control_type->idr; 527 } else { 528 power_zone->dev.parent = &parent->dev; 529 power_zone->parent_idr = &parent->idr; 530 } 531 power_zone->dev.class = &powercap_class; 532 533 mutex_lock(&control_type->lock); 534 /* Using idr to get the unique id */ 535 result = idr_alloc(power_zone->parent_idr, NULL, 0, 0, GFP_KERNEL); 536 if (result < 0) 537 goto err_idr_alloc; 538 539 power_zone->id = result; 540 idr_init(&power_zone->idr); 541 power_zone->name = kstrdup(name, GFP_KERNEL); 542 if (!power_zone->name) 543 goto err_name_alloc; 544 dev_set_name(&power_zone->dev, "%s:%x", 545 dev_name(power_zone->dev.parent), 546 power_zone->id); 547 power_zone->constraints = kzalloc(sizeof(*power_zone->constraints) * 548 nr_constraints, GFP_KERNEL); 549 if (!power_zone->constraints) 550 goto err_const_alloc; 551 552 nr_attrs = nr_constraints * POWERCAP_CONSTRAINTS_ATTRS + 553 POWERCAP_ZONE_MAX_ATTRS + 1; 554 power_zone->zone_dev_attrs = kzalloc(sizeof(void *) * 555 nr_attrs, GFP_KERNEL); 556 if (!power_zone->zone_dev_attrs) 557 goto err_attr_alloc; 558 create_power_zone_common_attributes(power_zone); 559 result = create_constraints(power_zone, nr_constraints, const_ops); 560 if (result) 561 goto err_dev_ret; 562 563 power_zone->zone_dev_attrs[power_zone->zone_attr_count] = NULL; 564 power_zone->dev_zone_attr_group.attrs = power_zone->zone_dev_attrs; 565 power_zone->dev_attr_groups[0] = &power_zone->dev_zone_attr_group; 566 power_zone->dev_attr_groups[1] = NULL; 567 power_zone->dev.groups = power_zone->dev_attr_groups; 568 result = device_register(&power_zone->dev); 569 if (result) 570 goto err_dev_ret; 571 572 control_type->nr_zones++; 573 mutex_unlock(&control_type->lock); 574 575 return power_zone; 576 577err_dev_ret: 578 kfree(power_zone->zone_dev_attrs); 579err_attr_alloc: 580 kfree(power_zone->constraints); 581err_const_alloc: 582 kfree(power_zone->name); 583err_name_alloc: 584 idr_remove(power_zone->parent_idr, power_zone->id); 585err_idr_alloc: 586 if (power_zone->allocated) 587 kfree(power_zone); 588 mutex_unlock(&control_type->lock); 589 590 return ERR_PTR(result); 591} 592EXPORT_SYMBOL_GPL(powercap_register_zone); 593 594int powercap_unregister_zone(struct powercap_control_type *control_type, 595 struct powercap_zone *power_zone) 596{ 597 if (!power_zone || !control_type) 598 return -EINVAL; 599 600 mutex_lock(&control_type->lock); 601 control_type->nr_zones--; 602 mutex_unlock(&control_type->lock); 603 604 device_unregister(&power_zone->dev); 605 606 return 0; 607} 608EXPORT_SYMBOL_GPL(powercap_unregister_zone); 609 610struct powercap_control_type *powercap_register_control_type( 611 struct powercap_control_type *control_type, 612 const char *name, 613 const struct powercap_control_type_ops *ops) 614{ 615 int result; 616 617 if (!name) 618 return ERR_PTR(-EINVAL); 619 if (control_type) { 620 if (!ops || !ops->release) 621 return ERR_PTR(-EINVAL); 622 memset(control_type, 0, sizeof(*control_type)); 623 } else { 624 control_type = kzalloc(sizeof(*control_type), GFP_KERNEL); 625 if (!control_type) 626 return ERR_PTR(-ENOMEM); 627 control_type->allocated = true; 628 } 629 mutex_init(&control_type->lock); 630 control_type->ops = ops; 631 INIT_LIST_HEAD(&control_type->node); 632 control_type->dev.class = &powercap_class; 633 dev_set_name(&control_type->dev, "%s", name); 634 result = device_register(&control_type->dev); 635 if (result) { 636 if (control_type->allocated) 637 kfree(control_type); 638 return ERR_PTR(result); 639 } 640 idr_init(&control_type->idr); 641 642 mutex_lock(&powercap_cntrl_list_lock); 643 list_add_tail(&control_type->node, &powercap_cntrl_list); 644 mutex_unlock(&powercap_cntrl_list_lock); 645 646 return control_type; 647} 648EXPORT_SYMBOL_GPL(powercap_register_control_type); 649 650int powercap_unregister_control_type(struct powercap_control_type *control_type) 651{ 652 struct powercap_control_type *pos = NULL; 653 654 if (control_type->nr_zones) { 655 dev_err(&control_type->dev, "Zones of this type still not freed\n"); 656 return -EINVAL; 657 } 658 mutex_lock(&powercap_cntrl_list_lock); 659 list_for_each_entry(pos, &powercap_cntrl_list, node) { 660 if (pos == control_type) { 661 list_del(&control_type->node); 662 mutex_unlock(&powercap_cntrl_list_lock); 663 device_unregister(&control_type->dev); 664 return 0; 665 } 666 } 667 mutex_unlock(&powercap_cntrl_list_lock); 668 669 return -ENODEV; 670} 671EXPORT_SYMBOL_GPL(powercap_unregister_control_type); 672 673static int __init powercap_init(void) 674{ 675 int result = 0; 676 677 result = seed_constraint_attributes(); 678 if (result) 679 return result; 680 681 result = class_register(&powercap_class); 682 683 return result; 684} 685 686device_initcall(powercap_init); 687 688MODULE_DESCRIPTION("PowerCap sysfs Driver"); 689MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>"); 690MODULE_LICENSE("GPL v2"); 691