events/power.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #undef TRACE_SYSTEM
   3 #define TRACE_SYSTEM power
   4
   5 #if !defined(_TRACE_POWER_H) || defined(TRACE_HEADER_MULTI_READ)
   6 #define _TRACE_POWER_H
   7
   8 #include <linux/cpufreq.h>
   9 #include <linux/ktime.h>
  10 #include <linux/pm_qos.h>
  11 #include <linux/tracepoint.h>
  12 #include <linux/trace_events.h>
  13
  14 #define TPS(x)  tracepoint_string(x)
  15
  16 DECLARE_EVENT_CLASS(cpu,
  17
  18         TP_PROTO(unsigned int state, unsigned int cpu_id),
  19
  20         TP_ARGS(state, cpu_id),
  21
  22         TP_STRUCT__entry(
  23                 __field(        u32,            state           )
  24                 __field(        u32,            cpu_id          )
  25         ),
  26
  27         TP_fast_assign(
  28                 __entry->state = state;
  29                 __entry->cpu_id = cpu_id;
  30         ),
  31
  32         TP_printk("state=%lu cpu_id=%lu", (unsigned long)__entry->state,
  33                   (unsigned long)__entry->cpu_id)
  34 );
  35
  36 DEFINE_EVENT(cpu, cpu_idle,
  37
  38         TP_PROTO(unsigned int state, unsigned int cpu_id),
  39
  40         TP_ARGS(state, cpu_id)
  41 );
  42
  43 TRACE_EVENT(cpu_idle_miss,
  44
  45         TP_PROTO(unsigned int cpu_id, unsigned int state, bool below),
  46
  47         TP_ARGS(cpu_id, state, below),
  48
  49         TP_STRUCT__entry(
  50                 __field(u32,            cpu_id)
  51                 __field(u32,            state)
  52                 __field(bool,           below)
  53         ),
  54
  55         TP_fast_assign(
  56                 __entry->cpu_id = cpu_id;
  57                 __entry->state = state;
  58                 __entry->below = below;
  59         ),
  60
  61         TP_printk("cpu_id=%lu state=%lu type=%s", (unsigned long)__entry->cpu_id,
  62                 (unsigned long)__entry->state, (__entry->below)?"below":"above")
  63 );
  64
  65 TRACE_EVENT(powernv_throttle,
  66
  67         TP_PROTO(int chip_id, const char *reason, int pmax),
  68
  69         TP_ARGS(chip_id, reason, pmax),
  70
  71         TP_STRUCT__entry(
  72                 __field(int, chip_id)
  73                 __string(reason, reason)
  74                 __field(int, pmax)
  75         ),
  76
  77         TP_fast_assign(
  78                 __entry->chip_id = chip_id;
  79                 __assign_str(reason, reason);
  80                 __entry->pmax = pmax;
  81         ),
  82
  83         TP_printk("Chip %d Pmax %d %s", __entry->chip_id,
  84                   __entry->pmax, __get_str(reason))
  85 );
  86
  87 TRACE_EVENT(pstate_sample,
  88
  89         TP_PROTO(u32 core_busy,
  90                 u32 scaled_busy,
  91                 u32 from,
  92                 u32 to,
  93                 u64 mperf,
  94                 u64 aperf,
  95                 u64 tsc,
  96                 u32 freq,
  97                 u32 io_boost
  98                 ),
  99
 100         TP_ARGS(core_busy,
 101                 scaled_busy,
 102                 from,
 103                 to,
 104                 mperf,
 105                 aperf,
 106                 tsc,
 107                 freq,
 108                 io_boost
 109                 ),
 110
 111         TP_STRUCT__entry(
 112                 __field(u32, core_busy)
 113                 __field(u32, scaled_busy)
 114                 __field(u32, from)
 115                 __field(u32, to)
 116                 __field(u64, mperf)
 117                 __field(u64, aperf)
 118                 __field(u64, tsc)
 119                 __field(u32, freq)
 120                 __field(u32, io_boost)
 121                 ),
 122
 123         TP_fast_assign(
 124                 __entry->core_busy = core_busy;
 125                 __entry->scaled_busy = scaled_busy;
 126                 __entry->from = from;
 127                 __entry->to = to;
 128                 __entry->mperf = mperf;
 129                 __entry->aperf = aperf;
 130                 __entry->tsc = tsc;
 131                 __entry->freq = freq;
 132                 __entry->io_boost = io_boost;
 133                 ),
 134
 135         TP_printk("core_busy=%lu scaled=%lu from=%lu to=%lu mperf=%llu aperf=%llu tsc=%llu freq=%lu io_boost=%lu",
 136                 (unsigned long)__entry->core_busy,
 137                 (unsigned long)__entry->scaled_busy,
 138                 (unsigned long)__entry->from,
 139                 (unsigned long)__entry->to,
 140                 (unsigned long long)__entry->mperf,
 141                 (unsigned long long)__entry->aperf,
 142                 (unsigned long long)__entry->tsc,
 143                 (unsigned long)__entry->freq,
 144                 (unsigned long)__entry->io_boost
 145                 )
 146
 147 );
 148
 149 /* This file can get included multiple times, TRACE_HEADER_MULTI_READ at top */
 150 #ifndef _PWR_EVENT_AVOID_DOUBLE_DEFINING
 151 #define _PWR_EVENT_AVOID_DOUBLE_DEFINING
 152
 153 #define PWR_EVENT_EXIT -1
 154 #endif
 155
 156 #define pm_verb_symbolic(event) \
 157         __print_symbolic(event, \
 158                 { PM_EVENT_SUSPEND, "suspend" }, \
 159                 { PM_EVENT_RESUME, "resume" }, \
 160                 { PM_EVENT_FREEZE, "freeze" }, \
 161                 { PM_EVENT_QUIESCE, "quiesce" }, \
 162                 { PM_EVENT_HIBERNATE, "hibernate" }, \
 163                 { PM_EVENT_THAW, "thaw" }, \
 164                 { PM_EVENT_RESTORE, "restore" }, \
 165                 { PM_EVENT_RECOVER, "recover" })
 166
 167 DEFINE_EVENT(cpu, cpu_frequency,
 168
 169         TP_PROTO(unsigned int frequency, unsigned int cpu_id),
 170
 171         TP_ARGS(frequency, cpu_id)
 172 );
 173
 174 TRACE_EVENT(cpu_frequency_limits,
 175
 176         TP_PROTO(struct cpufreq_policy *policy),
 177
 178         TP_ARGS(policy),
 179
 180         TP_STRUCT__entry(
 181                 __field(u32, min_freq)
 182                 __field(u32, max_freq)
 183                 __field(u32, cpu_id)
 184         ),
 185
 186         TP_fast_assign(
 187                 __entry->min_freq = policy->min;
 188                 __entry->max_freq = policy->max;
 189                 __entry->cpu_id = policy->cpu;
 190         ),
 191
 192         TP_printk("min=%lu max=%lu cpu_id=%lu",
 193                   (unsigned long)__entry->min_freq,
 194                   (unsigned long)__entry->max_freq,
 195                   (unsigned long)__entry->cpu_id)
 196 );
 197
 198 TRACE_EVENT(device_pm_callback_start,
 199
 200         TP_PROTO(struct device *dev, const char *pm_ops, int event),
 201
 202         TP_ARGS(dev, pm_ops, event),
 203
 204         TP_STRUCT__entry(
 205                 __string(device, dev_name(dev))
 206                 __string(driver, dev_driver_string(dev))
 207                 __string(parent, dev->parent ? dev_name(dev->parent) : "none")
 208                 __string(pm_ops, pm_ops ? pm_ops : "none ")
 209                 __field(int, event)
 210         ),
 211
 212         TP_fast_assign(
 213                 __assign_str(device, dev_name(dev));
 214                 __assign_str(driver, dev_driver_string(dev));
 215                 __assign_str(parent,
 216                         dev->parent ? dev_name(dev->parent) : "none");
 217                 __assign_str(pm_ops, pm_ops ? pm_ops : "none ");
 218                 __entry->event = event;
 219         ),
 220
 221         TP_printk("%s %s, parent: %s, %s[%s]", __get_str(driver),
 222                 __get_str(device), __get_str(parent), __get_str(pm_ops),
 223                 pm_verb_symbolic(__entry->event))
 224 );
 225
 226 TRACE_EVENT(device_pm_callback_end,
 227
 228         TP_PROTO(struct device *dev, int error),
 229
 230         TP_ARGS(dev, error),
 231
 232         TP_STRUCT__entry(
 233                 __string(device, dev_name(dev))
 234                 __string(driver, dev_driver_string(dev))
 235                 __field(int, error)
 236         ),
 237
 238         TP_fast_assign(
 239                 __assign_str(device, dev_name(dev));
 240                 __assign_str(driver, dev_driver_string(dev));
 241                 __entry->error = error;
 242         ),
 243
 244         TP_printk("%s %s, err=%d",
 245                 __get_str(driver), __get_str(device), __entry->error)
 246 );
 247
 248 TRACE_EVENT(suspend_resume,
 249
 250         TP_PROTO(const char *action, int val, bool start),
 251
 252         TP_ARGS(action, val, start),
 253
 254         TP_STRUCT__entry(
 255                 __field(const char *, action)
 256                 __field(int, val)
 257                 __field(bool, start)
 258         ),
 259
 260         TP_fast_assign(
 261                 __entry->action = action;
 262                 __entry->val = val;
 263                 __entry->start = start;
 264         ),
 265
 266         TP_printk("%s[%u] %s", __entry->action, (unsigned int)__entry->val,
 267                 (__entry->start)?"begin":"end")
 268 );
 269
 270 DECLARE_EVENT_CLASS(wakeup_source,
 271
 272         TP_PROTO(const char *name, unsigned int state),
 273
 274         TP_ARGS(name, state),
 275
 276         TP_STRUCT__entry(
 277                 __string(       name,           name            )
 278                 __field(        u64,            state           )
 279         ),
 280
 281         TP_fast_assign(
 282                 __assign_str(name, name);
 283                 __entry->state = state;
 284         ),
 285
 286         TP_printk("%s state=0x%lx", __get_str(name),
 287                 (unsigned long)__entry->state)
 288 );
 289
 290 DEFINE_EVENT(wakeup_source, wakeup_source_activate,
 291
 292         TP_PROTO(const char *name, unsigned int state),
 293
 294         TP_ARGS(name, state)
 295 );
 296
 297 DEFINE_EVENT(wakeup_source, wakeup_source_deactivate,
 298
 299         TP_PROTO(const char *name, unsigned int state),
 300
 301         TP_ARGS(name, state)
 302 );
 303
 304 /*
 305  * The clock events are used for clock enable/disable and for
 306  *  clock rate change
 307  */
 308 DECLARE_EVENT_CLASS(clock,
 309
 310         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
 311
 312         TP_ARGS(name, state, cpu_id),
 313
 314         TP_STRUCT__entry(
 315                 __string(       name,           name            )
 316                 __field(        u64,            state           )
 317                 __field(        u64,            cpu_id          )
 318         ),
 319
 320         TP_fast_assign(
 321                 __assign_str(name, name);
 322                 __entry->state = state;
 323                 __entry->cpu_id = cpu_id;
 324         ),
 325
 326         TP_printk("%s state=%lu cpu_id=%lu", __get_str(name),
 327                 (unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
 328 );
 329
 330 DEFINE_EVENT(clock, clock_enable,
 331
 332         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
 333
 334         TP_ARGS(name, state, cpu_id)
 335 );
 336
 337 DEFINE_EVENT(clock, clock_disable,
 338
 339         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
 340
 341         TP_ARGS(name, state, cpu_id)
 342 );
 343
 344 DEFINE_EVENT(clock, clock_set_rate,
 345
 346         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
 347
 348         TP_ARGS(name, state, cpu_id)
 349 );
 350
 351 /*
 352  * The power domain events are used for power domains transitions
 353  */
 354 DECLARE_EVENT_CLASS(power_domain,
 355
 356         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
 357
 358         TP_ARGS(name, state, cpu_id),
 359
 360         TP_STRUCT__entry(
 361                 __string(       name,           name            )
 362                 __field(        u64,            state           )
 363                 __field(        u64,            cpu_id          )
 364         ),
 365
 366         TP_fast_assign(
 367                 __assign_str(name, name);
 368                 __entry->state = state;
 369                 __entry->cpu_id = cpu_id;
 370 ),
 371
 372         TP_printk("%s state=%lu cpu_id=%lu", __get_str(name),
 373                 (unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
 374 );
 375
 376 DEFINE_EVENT(power_domain, power_domain_target,
 377
 378         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
 379
 380         TP_ARGS(name, state, cpu_id)
 381 );
 382
 383 /*
 384  * CPU latency QoS events used for global CPU latency QoS list updates
 385  */
 386 DECLARE_EVENT_CLASS(cpu_latency_qos_request,
 387
 388         TP_PROTO(s32 value),
 389
 390         TP_ARGS(value),
 391
 392         TP_STRUCT__entry(
 393                 __field( s32,                    value          )
 394         ),
 395
 396         TP_fast_assign(
 397                 __entry->value = value;
 398         ),
 399
 400         TP_printk("CPU_DMA_LATENCY value=%d",
 401                   __entry->value)
 402 );
 403
 404 DEFINE_EVENT(cpu_latency_qos_request, pm_qos_add_request,
 405
 406         TP_PROTO(s32 value),
 407
 408         TP_ARGS(value)
 409 );
 410
 411 DEFINE_EVENT(cpu_latency_qos_request, pm_qos_update_request,
 412
 413         TP_PROTO(s32 value),
 414
 415         TP_ARGS(value)
 416 );
 417
 418 DEFINE_EVENT(cpu_latency_qos_request, pm_qos_remove_request,
 419
 420         TP_PROTO(s32 value),
 421
 422         TP_ARGS(value)
 423 );
 424
 425 /*
 426  * General PM QoS events used for updates of PM QoS request lists
 427  */
 428 DECLARE_EVENT_CLASS(pm_qos_update,
 429
 430         TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
 431
 432         TP_ARGS(action, prev_value, curr_value),
 433
 434         TP_STRUCT__entry(
 435                 __field( enum pm_qos_req_action, action         )
 436                 __field( int,                    prev_value     )
 437                 __field( int,                    curr_value     )
 438         ),
 439
 440         TP_fast_assign(
 441                 __entry->action = action;
 442                 __entry->prev_value = prev_value;
 443                 __entry->curr_value = curr_value;
 444         ),
 445
 446         TP_printk("action=%s prev_value=%d curr_value=%d",
 447                   __print_symbolic(__entry->action,
 448                         { PM_QOS_ADD_REQ,       "ADD_REQ" },
 449                         { PM_QOS_UPDATE_REQ,    "UPDATE_REQ" },
 450                         { PM_QOS_REMOVE_REQ,    "REMOVE_REQ" }),
 451                   __entry->prev_value, __entry->curr_value)
 452 );
 453
 454 DEFINE_EVENT(pm_qos_update, pm_qos_update_target,
 455
 456         TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
 457
 458         TP_ARGS(action, prev_value, curr_value)
 459 );
 460
 461 DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags,
 462
 463         TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
 464
 465         TP_ARGS(action, prev_value, curr_value),
 466
 467         TP_printk("action=%s prev_value=0x%x curr_value=0x%x",
 468                   __print_symbolic(__entry->action,
 469                         { PM_QOS_ADD_REQ,       "ADD_REQ" },
 470                         { PM_QOS_UPDATE_REQ,    "UPDATE_REQ" },
 471                         { PM_QOS_REMOVE_REQ,    "REMOVE_REQ" }),
 472                   __entry->prev_value, __entry->curr_value)
 473 );
 474
 475 DECLARE_EVENT_CLASS(dev_pm_qos_request,
 476
 477         TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
 478                  s32 new_value),
 479
 480         TP_ARGS(name, type, new_value),
 481
 482         TP_STRUCT__entry(
 483                 __string( name,                    name         )
 484                 __field( enum dev_pm_qos_req_type, type         )
 485                 __field( s32,                      new_value    )
 486         ),
 487
 488         TP_fast_assign(
 489                 __assign_str(name, name);
 490                 __entry->type = type;
 491                 __entry->new_value = new_value;
 492         ),
 493
 494         TP_printk("device=%s type=%s new_value=%d",
 495                   __get_str(name),
 496                   __print_symbolic(__entry->type,
 497                         { DEV_PM_QOS_RESUME_LATENCY, "DEV_PM_QOS_RESUME_LATENCY" },
 498                         { DEV_PM_QOS_FLAGS, "DEV_PM_QOS_FLAGS" }),
 499                   __entry->new_value)
 500 );
 501
 502 DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request,
 503
 504         TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
 505                  s32 new_value),
 506
 507         TP_ARGS(name, type, new_value)
 508 );
 509
 510 DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request,
 511
 512         TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
 513                  s32 new_value),
 514
 515         TP_ARGS(name, type, new_value)
 516 );
 517
 518 DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,
 519
 520         TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
 521                  s32 new_value),
 522
 523         TP_ARGS(name, type, new_value)
 524 );
 525
 526 TRACE_EVENT(guest_halt_poll_ns,
 527
 528         TP_PROTO(bool grow, unsigned int new, unsigned int old),
 529
 530         TP_ARGS(grow, new, old),
 531
 532         TP_STRUCT__entry(
 533                 __field(bool, grow)
 534                 __field(unsigned int, new)
 535                 __field(unsigned int, old)
 536         ),
 537
 538         TP_fast_assign(
 539                 __entry->grow   = grow;
 540                 __entry->new    = new;
 541                 __entry->old    = old;
 542         ),
 543
 544         TP_printk("halt_poll_ns %u (%s %u)",
 545                 __entry->new,
 546                 __entry->grow ? "grow" : "shrink",
 547                 __entry->old)
 548 );
 549
 550 #define trace_guest_halt_poll_ns_grow(new, old) \
 551         trace_guest_halt_poll_ns(true, new, old)
 552 #define trace_guest_halt_poll_ns_shrink(new, old) \
 553         trace_guest_halt_poll_ns(false, new, old)
 554 #endif /* _TRACE_POWER_H */
 555
 556 /* This part must be outside protection */
 557 #include <trace/define_trace.h>