1// SPDX-License-Identifier: GPL-2.0 2/* 3 * System Control and Management Interface (SCMI) Powercap Protocol 4 * 5 * Copyright (C) 2022 ARM Ltd. 6 */ 7 8#define pr_fmt(fmt) "SCMI Notifications POWERCAP - " fmt 9 10#include <linux/bitfield.h> 11#include <linux/io.h> 12#include <linux/module.h> 13#include <linux/scmi_protocol.h> 14 15#include <trace/events/scmi.h> 16 17#include "protocols.h" 18#include "notify.h" 19 20/* Updated only after ALL the mandatory features for that version are merged */ 21#define SCMI_PROTOCOL_SUPPORTED_VERSION 0x20000 22 23enum scmi_powercap_protocol_cmd { 24 POWERCAP_DOMAIN_ATTRIBUTES = 0x3, 25 POWERCAP_CAP_GET = 0x4, 26 POWERCAP_CAP_SET = 0x5, 27 POWERCAP_PAI_GET = 0x6, 28 POWERCAP_PAI_SET = 0x7, 29 POWERCAP_DOMAIN_NAME_GET = 0x8, 30 POWERCAP_MEASUREMENTS_GET = 0x9, 31 POWERCAP_CAP_NOTIFY = 0xa, 32 POWERCAP_MEASUREMENTS_NOTIFY = 0xb, 33 POWERCAP_DESCRIBE_FASTCHANNEL = 0xc, 34}; 35 36enum { 37 POWERCAP_FC_CAP, 38 POWERCAP_FC_PAI, 39 POWERCAP_FC_MAX, 40}; 41 42struct scmi_msg_resp_powercap_domain_attributes { 43 __le32 attributes; 44#define SUPPORTS_POWERCAP_CAP_CHANGE_NOTIFY(x) ((x) & BIT(31)) 45#define SUPPORTS_POWERCAP_MEASUREMENTS_CHANGE_NOTIFY(x) ((x) & BIT(30)) 46#define SUPPORTS_ASYNC_POWERCAP_CAP_SET(x) ((x) & BIT(29)) 47#define SUPPORTS_EXTENDED_NAMES(x) ((x) & BIT(28)) 48#define SUPPORTS_POWERCAP_CAP_CONFIGURATION(x) ((x) & BIT(27)) 49#define SUPPORTS_POWERCAP_MONITORING(x) ((x) & BIT(26)) 50#define SUPPORTS_POWERCAP_PAI_CONFIGURATION(x) ((x) & BIT(25)) 51#define SUPPORTS_POWERCAP_FASTCHANNELS(x) ((x) & BIT(22)) 52#define POWERCAP_POWER_UNIT(x) \ 53 (FIELD_GET(GENMASK(24, 23), (x))) 54#define SUPPORTS_POWER_UNITS_MW(x) \ 55 (POWERCAP_POWER_UNIT(x) == 0x2) 56#define SUPPORTS_POWER_UNITS_UW(x) \ 57 (POWERCAP_POWER_UNIT(x) == 0x1) 58 u8 name[SCMI_SHORT_NAME_MAX_SIZE]; 59 __le32 min_pai; 60 __le32 max_pai; 61 __le32 pai_step; 62 __le32 min_power_cap; 63 __le32 max_power_cap; 64 __le32 power_cap_step; 65 __le32 sustainable_power; 66 __le32 accuracy; 67 __le32 parent_id; 68}; 69 70struct scmi_msg_powercap_set_cap_or_pai { 71 __le32 domain; 72 __le32 flags; 73#define CAP_SET_ASYNC BIT(1) 74#define CAP_SET_IGNORE_DRESP BIT(0) 75 __le32 value; 76}; 77 78struct scmi_msg_resp_powercap_cap_set_complete { 79 __le32 domain; 80 __le32 power_cap; 81}; 82 83struct scmi_msg_resp_powercap_meas_get { 84 __le32 power; 85 __le32 pai; 86}; 87 88struct scmi_msg_powercap_notify_cap { 89 __le32 domain; 90 __le32 notify_enable; 91}; 92 93struct scmi_msg_powercap_notify_thresh { 94 __le32 domain; 95 __le32 notify_enable; 96 __le32 power_thresh_low; 97 __le32 power_thresh_high; 98}; 99 100struct scmi_powercap_cap_changed_notify_payld { 101 __le32 agent_id; 102 __le32 domain_id; 103 __le32 power_cap; 104 __le32 pai; 105}; 106 107struct scmi_powercap_meas_changed_notify_payld { 108 __le32 agent_id; 109 __le32 domain_id; 110 __le32 power; 111}; 112 113struct scmi_powercap_state { 114 bool enabled; 115 u32 last_pcap; 116 bool meas_notif_enabled; 117 u64 thresholds; 118#define THRESH_LOW(p, id) \ 119 (lower_32_bits((p)->states[(id)].thresholds)) 120#define THRESH_HIGH(p, id) \ 121 (upper_32_bits((p)->states[(id)].thresholds)) 122}; 123 124struct powercap_info { 125 u32 version; 126 int num_domains; 127 bool notify_cap_cmd; 128 bool notify_measurements_cmd; 129 struct scmi_powercap_state *states; 130 struct scmi_powercap_info *powercaps; 131}; 132 133static enum scmi_powercap_protocol_cmd evt_2_cmd[] = { 134 POWERCAP_CAP_NOTIFY, 135 POWERCAP_MEASUREMENTS_NOTIFY, 136}; 137 138static int scmi_powercap_notify(const struct scmi_protocol_handle *ph, 139 u32 domain, int message_id, bool enable); 140 141static int 142scmi_powercap_attributes_get(const struct scmi_protocol_handle *ph, 143 struct powercap_info *pi) 144{ 145 int ret; 146 struct scmi_xfer *t; 147 148 ret = ph->xops->xfer_get_init(ph, PROTOCOL_ATTRIBUTES, 0, 149 sizeof(u32), &t); 150 if (ret) 151 return ret; 152 153 ret = ph->xops->do_xfer(ph, t); 154 if (!ret) { 155 u32 attributes; 156 157 attributes = get_unaligned_le32(t->rx.buf); 158 pi->num_domains = FIELD_GET(GENMASK(15, 0), attributes); 159 } 160 161 ph->xops->xfer_put(ph, t); 162 163 if (!ret) { 164 if (!ph->hops->protocol_msg_check(ph, 165 POWERCAP_CAP_NOTIFY, NULL)) 166 pi->notify_cap_cmd = true; 167 168 if (!ph->hops->protocol_msg_check(ph, 169 POWERCAP_MEASUREMENTS_NOTIFY, 170 NULL)) 171 pi->notify_measurements_cmd = true; 172 } 173 174 return ret; 175} 176 177static inline int 178scmi_powercap_validate(unsigned int min_val, unsigned int max_val, 179 unsigned int step_val, bool configurable) 180{ 181 if (!min_val || !max_val) 182 return -EPROTO; 183 184 if ((configurable && min_val == max_val) || 185 (!configurable && min_val != max_val)) 186 return -EPROTO; 187 188 if (min_val != max_val && !step_val) 189 return -EPROTO; 190 191 return 0; 192} 193 194static int 195scmi_powercap_domain_attributes_get(const struct scmi_protocol_handle *ph, 196 struct powercap_info *pinfo, u32 domain) 197{ 198 int ret; 199 u32 flags; 200 struct scmi_xfer *t; 201 struct scmi_powercap_info *dom_info = pinfo->powercaps + domain; 202 struct scmi_msg_resp_powercap_domain_attributes *resp; 203 204 ret = ph->xops->xfer_get_init(ph, POWERCAP_DOMAIN_ATTRIBUTES, 205 sizeof(domain), sizeof(*resp), &t); 206 if (ret) 207 return ret; 208 209 put_unaligned_le32(domain, t->tx.buf); 210 resp = t->rx.buf; 211 212 ret = ph->xops->do_xfer(ph, t); 213 if (!ret) { 214 flags = le32_to_cpu(resp->attributes); 215 216 dom_info->id = domain; 217 if (pinfo->notify_cap_cmd) 218 dom_info->notify_powercap_cap_change = 219 SUPPORTS_POWERCAP_CAP_CHANGE_NOTIFY(flags); 220 if (pinfo->notify_measurements_cmd) 221 dom_info->notify_powercap_measurement_change = 222 SUPPORTS_POWERCAP_MEASUREMENTS_CHANGE_NOTIFY(flags); 223 dom_info->async_powercap_cap_set = 224 SUPPORTS_ASYNC_POWERCAP_CAP_SET(flags); 225 dom_info->powercap_cap_config = 226 SUPPORTS_POWERCAP_CAP_CONFIGURATION(flags); 227 dom_info->powercap_monitoring = 228 SUPPORTS_POWERCAP_MONITORING(flags); 229 dom_info->powercap_pai_config = 230 SUPPORTS_POWERCAP_PAI_CONFIGURATION(flags); 231 dom_info->powercap_scale_mw = 232 SUPPORTS_POWER_UNITS_MW(flags); 233 dom_info->powercap_scale_uw = 234 SUPPORTS_POWER_UNITS_UW(flags); 235 dom_info->fastchannels = 236 SUPPORTS_POWERCAP_FASTCHANNELS(flags); 237 238 strscpy(dom_info->name, resp->name, SCMI_SHORT_NAME_MAX_SIZE); 239 240 dom_info->min_pai = le32_to_cpu(resp->min_pai); 241 dom_info->max_pai = le32_to_cpu(resp->max_pai); 242 dom_info->pai_step = le32_to_cpu(resp->pai_step); 243 ret = scmi_powercap_validate(dom_info->min_pai, 244 dom_info->max_pai, 245 dom_info->pai_step, 246 dom_info->powercap_pai_config); 247 if (ret) { 248 dev_err(ph->dev, 249 "Platform reported inconsistent PAI config for domain %d - %s\n", 250 dom_info->id, dom_info->name); 251 goto clean; 252 } 253 254 dom_info->min_power_cap = le32_to_cpu(resp->min_power_cap); 255 dom_info->max_power_cap = le32_to_cpu(resp->max_power_cap); 256 dom_info->power_cap_step = le32_to_cpu(resp->power_cap_step); 257 ret = scmi_powercap_validate(dom_info->min_power_cap, 258 dom_info->max_power_cap, 259 dom_info->power_cap_step, 260 dom_info->powercap_cap_config); 261 if (ret) { 262 dev_err(ph->dev, 263 "Platform reported inconsistent CAP config for domain %d - %s\n", 264 dom_info->id, dom_info->name); 265 goto clean; 266 } 267 268 dom_info->sustainable_power = 269 le32_to_cpu(resp->sustainable_power); 270 dom_info->accuracy = le32_to_cpu(resp->accuracy); 271 272 dom_info->parent_id = le32_to_cpu(resp->parent_id); 273 if (dom_info->parent_id != SCMI_POWERCAP_ROOT_ZONE_ID && 274 (dom_info->parent_id >= pinfo->num_domains || 275 dom_info->parent_id == dom_info->id)) { 276 dev_err(ph->dev, 277 "Platform reported inconsistent parent ID for domain %d - %s\n", 278 dom_info->id, dom_info->name); 279 ret = -ENODEV; 280 } 281 } 282 283clean: 284 ph->xops->xfer_put(ph, t); 285 286 /* 287 * If supported overwrite short name with the extended one; 288 * on error just carry on and use already provided short name. 289 */ 290 if (!ret && SUPPORTS_EXTENDED_NAMES(flags)) 291 ph->hops->extended_name_get(ph, POWERCAP_DOMAIN_NAME_GET, 292 domain, NULL, dom_info->name, 293 SCMI_MAX_STR_SIZE); 294 295 return ret; 296} 297 298static int scmi_powercap_num_domains_get(const struct scmi_protocol_handle *ph) 299{ 300 struct powercap_info *pi = ph->get_priv(ph); 301 302 return pi->num_domains; 303} 304 305static const struct scmi_powercap_info * 306scmi_powercap_dom_info_get(const struct scmi_protocol_handle *ph, u32 domain_id) 307{ 308 struct powercap_info *pi = ph->get_priv(ph); 309 310 if (domain_id >= pi->num_domains) 311 return NULL; 312 313 return pi->powercaps + domain_id; 314} 315 316static int scmi_powercap_xfer_cap_get(const struct scmi_protocol_handle *ph, 317 u32 domain_id, u32 *power_cap) 318{ 319 int ret; 320 struct scmi_xfer *t; 321 322 ret = ph->xops->xfer_get_init(ph, POWERCAP_CAP_GET, sizeof(u32), 323 sizeof(u32), &t); 324 if (ret) 325 return ret; 326 327 put_unaligned_le32(domain_id, t->tx.buf); 328 ret = ph->xops->do_xfer(ph, t); 329 if (!ret) 330 *power_cap = get_unaligned_le32(t->rx.buf); 331 332 ph->xops->xfer_put(ph, t); 333 334 return ret; 335} 336 337static int __scmi_powercap_cap_get(const struct scmi_protocol_handle *ph, 338 const struct scmi_powercap_info *dom, 339 u32 *power_cap) 340{ 341 if (dom->fc_info && dom->fc_info[POWERCAP_FC_CAP].get_addr) { 342 *power_cap = ioread32(dom->fc_info[POWERCAP_FC_CAP].get_addr); 343 trace_scmi_fc_call(SCMI_PROTOCOL_POWERCAP, POWERCAP_CAP_GET, 344 dom->id, *power_cap, 0); 345 return 0; 346 } 347 348 return scmi_powercap_xfer_cap_get(ph, dom->id, power_cap); 349} 350 351static int scmi_powercap_cap_get(const struct scmi_protocol_handle *ph, 352 u32 domain_id, u32 *power_cap) 353{ 354 const struct scmi_powercap_info *dom; 355 356 if (!power_cap) 357 return -EINVAL; 358 359 dom = scmi_powercap_dom_info_get(ph, domain_id); 360 if (!dom) 361 return -EINVAL; 362 363 return __scmi_powercap_cap_get(ph, dom, power_cap); 364} 365 366static int scmi_powercap_xfer_cap_set(const struct scmi_protocol_handle *ph, 367 const struct scmi_powercap_info *pc, 368 u32 power_cap, bool ignore_dresp) 369{ 370 int ret; 371 struct scmi_xfer *t; 372 struct scmi_msg_powercap_set_cap_or_pai *msg; 373 374 ret = ph->xops->xfer_get_init(ph, POWERCAP_CAP_SET, 375 sizeof(*msg), 0, &t); 376 if (ret) 377 return ret; 378 379 msg = t->tx.buf; 380 msg->domain = cpu_to_le32(pc->id); 381 msg->flags = 382 cpu_to_le32(FIELD_PREP(CAP_SET_ASYNC, pc->async_powercap_cap_set) | 383 FIELD_PREP(CAP_SET_IGNORE_DRESP, ignore_dresp)); 384 msg->value = cpu_to_le32(power_cap); 385 386 if (!pc->async_powercap_cap_set || ignore_dresp) { 387 ret = ph->xops->do_xfer(ph, t); 388 } else { 389 ret = ph->xops->do_xfer_with_response(ph, t); 390 if (!ret) { 391 struct scmi_msg_resp_powercap_cap_set_complete *resp; 392 393 resp = t->rx.buf; 394 if (le32_to_cpu(resp->domain) == pc->id) 395 dev_dbg(ph->dev, 396 "Powercap ID %d CAP set async to %u\n", 397 pc->id, 398 get_unaligned_le32(&resp->power_cap)); 399 else 400 ret = -EPROTO; 401 } 402 } 403 404 ph->xops->xfer_put(ph, t); 405 return ret; 406} 407 408static int __scmi_powercap_cap_set(const struct scmi_protocol_handle *ph, 409 struct powercap_info *pi, u32 domain_id, 410 u32 power_cap, bool ignore_dresp) 411{ 412 int ret = -EINVAL; 413 const struct scmi_powercap_info *pc; 414 415 pc = scmi_powercap_dom_info_get(ph, domain_id); 416 if (!pc || !pc->powercap_cap_config) 417 return ret; 418 419 if (power_cap && 420 (power_cap < pc->min_power_cap || power_cap > pc->max_power_cap)) 421 return ret; 422 423 if (pc->fc_info && pc->fc_info[POWERCAP_FC_CAP].set_addr) { 424 struct scmi_fc_info *fci = &pc->fc_info[POWERCAP_FC_CAP]; 425 426 iowrite32(power_cap, fci->set_addr); 427 ph->hops->fastchannel_db_ring(fci->set_db); 428 trace_scmi_fc_call(SCMI_PROTOCOL_POWERCAP, POWERCAP_CAP_SET, 429 domain_id, power_cap, 0); 430 ret = 0; 431 } else { 432 ret = scmi_powercap_xfer_cap_set(ph, pc, power_cap, 433 ignore_dresp); 434 } 435 436 /* Save the last explicitly set non-zero powercap value */ 437 if (PROTOCOL_REV_MAJOR(pi->version) >= 0x2 && !ret && power_cap) 438 pi->states[domain_id].last_pcap = power_cap; 439 440 return ret; 441} 442 443static int scmi_powercap_cap_set(const struct scmi_protocol_handle *ph, 444 u32 domain_id, u32 power_cap, 445 bool ignore_dresp) 446{ 447 struct powercap_info *pi = ph->get_priv(ph); 448 449 /* 450 * Disallow zero as a possible explicitly requested powercap: 451 * there are enable/disable operations for this. 452 */ 453 if (!power_cap) 454 return -EINVAL; 455 456 /* Just log the last set request if acting on a disabled domain */ 457 if (PROTOCOL_REV_MAJOR(pi->version) >= 0x2 && 458 !pi->states[domain_id].enabled) { 459 pi->states[domain_id].last_pcap = power_cap; 460 return 0; 461 } 462 463 return __scmi_powercap_cap_set(ph, pi, domain_id, 464 power_cap, ignore_dresp); 465} 466 467static int scmi_powercap_xfer_pai_get(const struct scmi_protocol_handle *ph, 468 u32 domain_id, u32 *pai) 469{ 470 int ret; 471 struct scmi_xfer *t; 472 473 ret = ph->xops->xfer_get_init(ph, POWERCAP_PAI_GET, sizeof(u32), 474 sizeof(u32), &t); 475 if (ret) 476 return ret; 477 478 put_unaligned_le32(domain_id, t->tx.buf); 479 ret = ph->xops->do_xfer(ph, t); 480 if (!ret) 481 *pai = get_unaligned_le32(t->rx.buf); 482 483 ph->xops->xfer_put(ph, t); 484 485 return ret; 486} 487 488static int scmi_powercap_pai_get(const struct scmi_protocol_handle *ph, 489 u32 domain_id, u32 *pai) 490{ 491 struct scmi_powercap_info *dom; 492 struct powercap_info *pi = ph->get_priv(ph); 493 494 if (!pai || domain_id >= pi->num_domains) 495 return -EINVAL; 496 497 dom = pi->powercaps + domain_id; 498 if (dom->fc_info && dom->fc_info[POWERCAP_FC_PAI].get_addr) { 499 *pai = ioread32(dom->fc_info[POWERCAP_FC_PAI].get_addr); 500 trace_scmi_fc_call(SCMI_PROTOCOL_POWERCAP, POWERCAP_PAI_GET, 501 domain_id, *pai, 0); 502 return 0; 503 } 504 505 return scmi_powercap_xfer_pai_get(ph, domain_id, pai); 506} 507 508static int scmi_powercap_xfer_pai_set(const struct scmi_protocol_handle *ph, 509 u32 domain_id, u32 pai) 510{ 511 int ret; 512 struct scmi_xfer *t; 513 struct scmi_msg_powercap_set_cap_or_pai *msg; 514 515 ret = ph->xops->xfer_get_init(ph, POWERCAP_PAI_SET, 516 sizeof(*msg), 0, &t); 517 if (ret) 518 return ret; 519 520 msg = t->tx.buf; 521 msg->domain = cpu_to_le32(domain_id); 522 msg->flags = cpu_to_le32(0); 523 msg->value = cpu_to_le32(pai); 524 525 ret = ph->xops->do_xfer(ph, t); 526 527 ph->xops->xfer_put(ph, t); 528 return ret; 529} 530 531static int scmi_powercap_pai_set(const struct scmi_protocol_handle *ph, 532 u32 domain_id, u32 pai) 533{ 534 const struct scmi_powercap_info *pc; 535 536 pc = scmi_powercap_dom_info_get(ph, domain_id); 537 if (!pc || !pc->powercap_pai_config || !pai || 538 pai < pc->min_pai || pai > pc->max_pai) 539 return -EINVAL; 540 541 if (pc->fc_info && pc->fc_info[POWERCAP_FC_PAI].set_addr) { 542 struct scmi_fc_info *fci = &pc->fc_info[POWERCAP_FC_PAI]; 543 544 trace_scmi_fc_call(SCMI_PROTOCOL_POWERCAP, POWERCAP_PAI_SET, 545 domain_id, pai, 0); 546 iowrite32(pai, fci->set_addr); 547 ph->hops->fastchannel_db_ring(fci->set_db); 548 return 0; 549 } 550 551 return scmi_powercap_xfer_pai_set(ph, domain_id, pai); 552} 553 554static int scmi_powercap_measurements_get(const struct scmi_protocol_handle *ph, 555 u32 domain_id, u32 *average_power, 556 u32 *pai) 557{ 558 int ret; 559 struct scmi_xfer *t; 560 struct scmi_msg_resp_powercap_meas_get *resp; 561 const struct scmi_powercap_info *pc; 562 563 pc = scmi_powercap_dom_info_get(ph, domain_id); 564 if (!pc || !pc->powercap_monitoring || !pai || !average_power) 565 return -EINVAL; 566 567 ret = ph->xops->xfer_get_init(ph, POWERCAP_MEASUREMENTS_GET, 568 sizeof(u32), sizeof(*resp), &t); 569 if (ret) 570 return ret; 571 572 resp = t->rx.buf; 573 put_unaligned_le32(domain_id, t->tx.buf); 574 ret = ph->xops->do_xfer(ph, t); 575 if (!ret) { 576 *average_power = le32_to_cpu(resp->power); 577 *pai = le32_to_cpu(resp->pai); 578 } 579 580 ph->xops->xfer_put(ph, t); 581 return ret; 582} 583 584static int 585scmi_powercap_measurements_threshold_get(const struct scmi_protocol_handle *ph, 586 u32 domain_id, u32 *power_thresh_low, 587 u32 *power_thresh_high) 588{ 589 struct powercap_info *pi = ph->get_priv(ph); 590 591 if (!power_thresh_low || !power_thresh_high || 592 domain_id >= pi->num_domains) 593 return -EINVAL; 594 595 *power_thresh_low = THRESH_LOW(pi, domain_id); 596 *power_thresh_high = THRESH_HIGH(pi, domain_id); 597 598 return 0; 599} 600 601static int 602scmi_powercap_measurements_threshold_set(const struct scmi_protocol_handle *ph, 603 u32 domain_id, u32 power_thresh_low, 604 u32 power_thresh_high) 605{ 606 int ret = 0; 607 struct powercap_info *pi = ph->get_priv(ph); 608 609 if (domain_id >= pi->num_domains || 610 power_thresh_low > power_thresh_high) 611 return -EINVAL; 612 613 /* Anything to do ? */ 614 if (THRESH_LOW(pi, domain_id) == power_thresh_low && 615 THRESH_HIGH(pi, domain_id) == power_thresh_high) 616 return ret; 617 618 pi->states[domain_id].thresholds = 619 (FIELD_PREP(GENMASK_ULL(31, 0), power_thresh_low) | 620 FIELD_PREP(GENMASK_ULL(63, 32), power_thresh_high)); 621 622 /* Update thresholds if notification already enabled */ 623 if (pi->states[domain_id].meas_notif_enabled) 624 ret = scmi_powercap_notify(ph, domain_id, 625 POWERCAP_MEASUREMENTS_NOTIFY, 626 true); 627 628 return ret; 629} 630 631static int scmi_powercap_cap_enable_set(const struct scmi_protocol_handle *ph, 632 u32 domain_id, bool enable) 633{ 634 int ret; 635 u32 power_cap; 636 struct powercap_info *pi = ph->get_priv(ph); 637 638 if (PROTOCOL_REV_MAJOR(pi->version) < 0x2) 639 return -EINVAL; 640 641 if (enable == pi->states[domain_id].enabled) 642 return 0; 643 644 if (enable) { 645 /* Cannot enable with a zero powercap. */ 646 if (!pi->states[domain_id].last_pcap) 647 return -EINVAL; 648 649 ret = __scmi_powercap_cap_set(ph, pi, domain_id, 650 pi->states[domain_id].last_pcap, 651 true); 652 } else { 653 ret = __scmi_powercap_cap_set(ph, pi, domain_id, 0, true); 654 } 655 656 if (ret) 657 return ret; 658 659 /* 660 * Update our internal state to reflect final platform state: the SCMI 661 * server could have ignored a disable request and kept enforcing some 662 * powercap limit requested by other agents. 663 */ 664 ret = scmi_powercap_cap_get(ph, domain_id, &power_cap); 665 if (!ret) 666 pi->states[domain_id].enabled = !!power_cap; 667 668 return ret; 669} 670 671static int scmi_powercap_cap_enable_get(const struct scmi_protocol_handle *ph, 672 u32 domain_id, bool *enable) 673{ 674 int ret; 675 u32 power_cap; 676 struct powercap_info *pi = ph->get_priv(ph); 677 678 *enable = true; 679 if (PROTOCOL_REV_MAJOR(pi->version) < 0x2) 680 return 0; 681 682 /* 683 * Report always real platform state; platform could have ignored 684 * a previous disable request. Default true on any error. 685 */ 686 ret = scmi_powercap_cap_get(ph, domain_id, &power_cap); 687 if (!ret) 688 *enable = !!power_cap; 689 690 /* Update internal state with current real platform state */ 691 pi->states[domain_id].enabled = *enable; 692 693 return 0; 694} 695 696static const struct scmi_powercap_proto_ops powercap_proto_ops = { 697 .num_domains_get = scmi_powercap_num_domains_get, 698 .info_get = scmi_powercap_dom_info_get, 699 .cap_get = scmi_powercap_cap_get, 700 .cap_set = scmi_powercap_cap_set, 701 .cap_enable_set = scmi_powercap_cap_enable_set, 702 .cap_enable_get = scmi_powercap_cap_enable_get, 703 .pai_get = scmi_powercap_pai_get, 704 .pai_set = scmi_powercap_pai_set, 705 .measurements_get = scmi_powercap_measurements_get, 706 .measurements_threshold_set = scmi_powercap_measurements_threshold_set, 707 .measurements_threshold_get = scmi_powercap_measurements_threshold_get, 708}; 709 710static void scmi_powercap_domain_init_fc(const struct scmi_protocol_handle *ph, 711 u32 domain, struct scmi_fc_info **p_fc) 712{ 713 struct scmi_fc_info *fc; 714 715 fc = devm_kcalloc(ph->dev, POWERCAP_FC_MAX, sizeof(*fc), GFP_KERNEL); 716 if (!fc) 717 return; 718 719 ph->hops->fastchannel_init(ph, POWERCAP_DESCRIBE_FASTCHANNEL, 720 POWERCAP_CAP_SET, 4, domain, 721 &fc[POWERCAP_FC_CAP].set_addr, 722 &fc[POWERCAP_FC_CAP].set_db, 723 &fc[POWERCAP_FC_CAP].rate_limit); 724 725 ph->hops->fastchannel_init(ph, POWERCAP_DESCRIBE_FASTCHANNEL, 726 POWERCAP_CAP_GET, 4, domain, 727 &fc[POWERCAP_FC_CAP].get_addr, NULL, 728 &fc[POWERCAP_FC_CAP].rate_limit); 729 730 ph->hops->fastchannel_init(ph, POWERCAP_DESCRIBE_FASTCHANNEL, 731 POWERCAP_PAI_SET, 4, domain, 732 &fc[POWERCAP_FC_PAI].set_addr, 733 &fc[POWERCAP_FC_PAI].set_db, 734 &fc[POWERCAP_FC_PAI].rate_limit); 735 736 ph->hops->fastchannel_init(ph, POWERCAP_DESCRIBE_FASTCHANNEL, 737 POWERCAP_PAI_GET, 4, domain, 738 &fc[POWERCAP_FC_PAI].get_addr, NULL, 739 &fc[POWERCAP_FC_PAI].rate_limit); 740 741 *p_fc = fc; 742} 743 744static int scmi_powercap_notify(const struct scmi_protocol_handle *ph, 745 u32 domain, int message_id, bool enable) 746{ 747 int ret; 748 struct scmi_xfer *t; 749 750 switch (message_id) { 751 case POWERCAP_CAP_NOTIFY: 752 { 753 struct scmi_msg_powercap_notify_cap *notify; 754 755 ret = ph->xops->xfer_get_init(ph, message_id, 756 sizeof(*notify), 0, &t); 757 if (ret) 758 return ret; 759 760 notify = t->tx.buf; 761 notify->domain = cpu_to_le32(domain); 762 notify->notify_enable = cpu_to_le32(enable ? BIT(0) : 0); 763 break; 764 } 765 case POWERCAP_MEASUREMENTS_NOTIFY: 766 { 767 u32 low, high; 768 struct scmi_msg_powercap_notify_thresh *notify; 769 770 /* 771 * Note that we have to pick the most recently configured 772 * thresholds to build a proper POWERCAP_MEASUREMENTS_NOTIFY 773 * enable request and we fail, complaining, if no thresholds 774 * were ever set, since this is an indication the API has been 775 * used wrongly. 776 */ 777 ret = scmi_powercap_measurements_threshold_get(ph, domain, 778 &low, &high); 779 if (ret) 780 return ret; 781 782 if (enable && !low && !high) { 783 dev_err(ph->dev, 784 "Invalid Measurements Notify thresholds: %u/%u\n", 785 low, high); 786 return -EINVAL; 787 } 788 789 ret = ph->xops->xfer_get_init(ph, message_id, 790 sizeof(*notify), 0, &t); 791 if (ret) 792 return ret; 793 794 notify = t->tx.buf; 795 notify->domain = cpu_to_le32(domain); 796 notify->notify_enable = cpu_to_le32(enable ? BIT(0) : 0); 797 notify->power_thresh_low = cpu_to_le32(low); 798 notify->power_thresh_high = cpu_to_le32(high); 799 break; 800 } 801 default: 802 return -EINVAL; 803 } 804 805 ret = ph->xops->do_xfer(ph, t); 806 807 ph->xops->xfer_put(ph, t); 808 return ret; 809} 810 811static bool 812scmi_powercap_notify_supported(const struct scmi_protocol_handle *ph, 813 u8 evt_id, u32 src_id) 814{ 815 bool supported = false; 816 const struct scmi_powercap_info *dom_info; 817 struct powercap_info *pi = ph->get_priv(ph); 818 819 if (evt_id >= ARRAY_SIZE(evt_2_cmd) || src_id >= pi->num_domains) 820 return false; 821 822 dom_info = pi->powercaps + src_id; 823 if (evt_id == SCMI_EVENT_POWERCAP_CAP_CHANGED) 824 supported = dom_info->notify_powercap_cap_change; 825 else if (evt_id == SCMI_EVENT_POWERCAP_MEASUREMENTS_CHANGED) 826 supported = dom_info->notify_powercap_measurement_change; 827 828 return supported; 829} 830 831static int 832scmi_powercap_set_notify_enabled(const struct scmi_protocol_handle *ph, 833 u8 evt_id, u32 src_id, bool enable) 834{ 835 int ret, cmd_id; 836 struct powercap_info *pi = ph->get_priv(ph); 837 838 if (evt_id >= ARRAY_SIZE(evt_2_cmd) || src_id >= pi->num_domains) 839 return -EINVAL; 840 841 cmd_id = evt_2_cmd[evt_id]; 842 ret = scmi_powercap_notify(ph, src_id, cmd_id, enable); 843 if (ret) 844 pr_debug("FAIL_ENABLED - evt[%X] dom[%d] - ret:%d\n", 845 evt_id, src_id, ret); 846 else if (cmd_id == POWERCAP_MEASUREMENTS_NOTIFY) 847 /* 848 * On success save the current notification enabled state, so 849 * as to be able to properly update the notification thresholds 850 * when they are modified on a domain for which measurement 851 * notifications were currently enabled. 852 * 853 * This is needed because the SCMI Notification core machinery 854 * and API does not support passing per-notification custom 855 * arguments at callback registration time. 856 * 857 * Note that this can be done here with a simple flag since the 858 * SCMI core Notifications code takes care of keeping proper 859 * per-domain enables refcounting, so that this helper function 860 * will be called only once (for enables) when the first user 861 * registers a callback on this domain and once more (disable) 862 * when the last user de-registers its callback. 863 */ 864 pi->states[src_id].meas_notif_enabled = enable; 865 866 return ret; 867} 868 869static void * 870scmi_powercap_fill_custom_report(const struct scmi_protocol_handle *ph, 871 u8 evt_id, ktime_t timestamp, 872 const void *payld, size_t payld_sz, 873 void *report, u32 *src_id) 874{ 875 void *rep = NULL; 876 877 switch (evt_id) { 878 case SCMI_EVENT_POWERCAP_CAP_CHANGED: 879 { 880 const struct scmi_powercap_cap_changed_notify_payld *p = payld; 881 struct scmi_powercap_cap_changed_report *r = report; 882 883 if (sizeof(*p) != payld_sz) 884 break; 885 886 r->timestamp = timestamp; 887 r->agent_id = le32_to_cpu(p->agent_id); 888 r->domain_id = le32_to_cpu(p->domain_id); 889 r->power_cap = le32_to_cpu(p->power_cap); 890 r->pai = le32_to_cpu(p->pai); 891 *src_id = r->domain_id; 892 rep = r; 893 break; 894 } 895 case SCMI_EVENT_POWERCAP_MEASUREMENTS_CHANGED: 896 { 897 const struct scmi_powercap_meas_changed_notify_payld *p = payld; 898 struct scmi_powercap_meas_changed_report *r = report; 899 900 if (sizeof(*p) != payld_sz) 901 break; 902 903 r->timestamp = timestamp; 904 r->agent_id = le32_to_cpu(p->agent_id); 905 r->domain_id = le32_to_cpu(p->domain_id); 906 r->power = le32_to_cpu(p->power); 907 *src_id = r->domain_id; 908 rep = r; 909 break; 910 } 911 default: 912 break; 913 } 914 915 return rep; 916} 917 918static int 919scmi_powercap_get_num_sources(const struct scmi_protocol_handle *ph) 920{ 921 struct powercap_info *pi = ph->get_priv(ph); 922 923 if (!pi) 924 return -EINVAL; 925 926 return pi->num_domains; 927} 928 929static const struct scmi_event powercap_events[] = { 930 { 931 .id = SCMI_EVENT_POWERCAP_CAP_CHANGED, 932 .max_payld_sz = 933 sizeof(struct scmi_powercap_cap_changed_notify_payld), 934 .max_report_sz = 935 sizeof(struct scmi_powercap_cap_changed_report), 936 }, 937 { 938 .id = SCMI_EVENT_POWERCAP_MEASUREMENTS_CHANGED, 939 .max_payld_sz = 940 sizeof(struct scmi_powercap_meas_changed_notify_payld), 941 .max_report_sz = 942 sizeof(struct scmi_powercap_meas_changed_report), 943 }, 944}; 945 946static const struct scmi_event_ops powercap_event_ops = { 947 .is_notify_supported = scmi_powercap_notify_supported, 948 .get_num_sources = scmi_powercap_get_num_sources, 949 .set_notify_enabled = scmi_powercap_set_notify_enabled, 950 .fill_custom_report = scmi_powercap_fill_custom_report, 951}; 952 953static const struct scmi_protocol_events powercap_protocol_events = { 954 .queue_sz = SCMI_PROTO_QUEUE_SZ, 955 .ops = &powercap_event_ops, 956 .evts = powercap_events, 957 .num_events = ARRAY_SIZE(powercap_events), 958}; 959 960static int 961scmi_powercap_protocol_init(const struct scmi_protocol_handle *ph) 962{ 963 int domain, ret; 964 u32 version; 965 struct powercap_info *pinfo; 966 967 ret = ph->xops->version_get(ph, &version); 968 if (ret) 969 return ret; 970 971 dev_dbg(ph->dev, "Powercap Version %d.%d\n", 972 PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version)); 973 974 pinfo = devm_kzalloc(ph->dev, sizeof(*pinfo), GFP_KERNEL); 975 if (!pinfo) 976 return -ENOMEM; 977 978 ret = scmi_powercap_attributes_get(ph, pinfo); 979 if (ret) 980 return ret; 981 982 pinfo->powercaps = devm_kcalloc(ph->dev, pinfo->num_domains, 983 sizeof(*pinfo->powercaps), 984 GFP_KERNEL); 985 if (!pinfo->powercaps) 986 return -ENOMEM; 987 988 pinfo->states = devm_kcalloc(ph->dev, pinfo->num_domains, 989 sizeof(*pinfo->states), GFP_KERNEL); 990 if (!pinfo->states) 991 return -ENOMEM; 992 993 /* 994 * Note that any failure in retrieving any domain attribute leads to 995 * the whole Powercap protocol initialization failure: this way the 996 * reported Powercap domains are all assured, when accessed, to be well 997 * formed and correlated by sane parent-child relationship (if any). 998 */ 999 for (domain = 0; domain < pinfo->num_domains; domain++) { 1000 ret = scmi_powercap_domain_attributes_get(ph, pinfo, domain); 1001 if (ret) 1002 return ret; 1003 1004 if (pinfo->powercaps[domain].fastchannels) 1005 scmi_powercap_domain_init_fc(ph, domain, 1006 &pinfo->powercaps[domain].fc_info); 1007 1008 /* Grab initial state when disable is supported. */ 1009 if (PROTOCOL_REV_MAJOR(version) >= 0x2) { 1010 ret = __scmi_powercap_cap_get(ph, 1011 &pinfo->powercaps[domain], 1012 &pinfo->states[domain].last_pcap); 1013 if (ret) 1014 return ret; 1015 1016 pinfo->states[domain].enabled = 1017 !!pinfo->states[domain].last_pcap; 1018 } 1019 } 1020 1021 pinfo->version = version; 1022 return ph->set_priv(ph, pinfo, version); 1023} 1024 1025static const struct scmi_protocol scmi_powercap = { 1026 .id = SCMI_PROTOCOL_POWERCAP, 1027 .owner = THIS_MODULE, 1028 .instance_init = &scmi_powercap_protocol_init, 1029 .ops = &powercap_proto_ops, 1030 .events = &powercap_protocol_events, 1031 .supported_version = SCMI_PROTOCOL_SUPPORTED_VERSION, 1032}; 1033 1034DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(powercap, scmi_powercap) 1035