include/trace/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);
  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);
 214                 __assign_str(driver);
 215                 __assign_str(parent);
 216                 __assign_str(pm_ops);
 217                 __entry->event = event;
 218         ),
 219
 220         TP_printk("%s %s, parent: %s, %s[%s]", __get_str(driver),
 221                 __get_str(device), __get_str(parent), __get_str(pm_ops),
 222                 pm_verb_symbolic(__entry->event))
 223 );
 224
 225 TRACE_EVENT(device_pm_callback_end,
 226
 227         TP_PROTO(struct device *dev, int error),
 228
 229         TP_ARGS(dev, error),
 230
 231         TP_STRUCT__entry(
 232                 __string(device, dev_name(dev))
 233                 __string(driver, dev_driver_string(dev))
 234                 __field(int, error)
 235         ),
 236
 237         TP_fast_assign(
 238                 __assign_str(device);
 239                 __assign_str(driver);
 240                 __entry->error = error;
 241         ),
 242
 243         TP_printk("%s %s, err=%d",
 244                 __get_str(driver), __get_str(device), __entry->error)
 245 );
 246
 247 TRACE_EVENT(suspend_resume,
 248
 249         TP_PROTO(const char *action, int val, bool start),
 250
 251         TP_ARGS(action, val, start),
 252
 253         TP_STRUCT__entry(
 254                 __field(const char *, action)
 255                 __field(int, val)
 256                 __field(bool, start)
 257         ),
 258
 259         TP_fast_assign(
 260                 __entry->action = action;
 261                 __entry->val = val;
 262                 __entry->start = start;
 263         ),
 264
 265         TP_printk("%s[%u] %s", __entry->action, (unsigned int)__entry->val,
 266                 (__entry->start)?"begin":"end")
 267 );
 268
 269 DECLARE_EVENT_CLASS(wakeup_source,
 270
 271         TP_PROTO(const char *name, unsigned int state),
 272
 273         TP_ARGS(name, state),
 274
 275         TP_STRUCT__entry(
 276                 __string(       name,           name            )
 277                 __field(        u64,            state           )
 278         ),
 279
 280         TP_fast_assign(
 281                 __assign_str(name);
 282                 __entry->state = state;
 283         ),
 284
 285         TP_printk("%s state=0x%lx", __get_str(name),
 286                 (unsigned long)__entry->state)
 287 );
 288
 289 DEFINE_EVENT(wakeup_source, wakeup_source_activate,
 290
 291         TP_PROTO(const char *name, unsigned int state),
 292
 293         TP_ARGS(name, state)
 294 );
 295
 296 DEFINE_EVENT(wakeup_source, wakeup_source_deactivate,
 297
 298         TP_PROTO(const char *name, unsigned int state),
 299
 300         TP_ARGS(name, state)
 301 );
 302
 303 /*
 304  * The clock events are used for clock enable/disable and for
 305  *  clock rate change
 306  */
 307 DECLARE_EVENT_CLASS(clock,
 308
 309         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
 310
 311         TP_ARGS(name, state, cpu_id),
 312
 313         TP_STRUCT__entry(
 314                 __string(       name,           name            )
 315                 __field(        u64,            state           )
 316                 __field(        u64,            cpu_id          )
 317         ),
 318
 319         TP_fast_assign(
 320                 __assign_str(name);
 321                 __entry->state = state;
 322                 __entry->cpu_id = cpu_id;
 323         ),
 324
 325         TP_printk("%s state=%lu cpu_id=%lu", __get_str(name),
 326                 (unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
 327 );
 328
 329 DEFINE_EVENT(clock, clock_enable,
 330
 331         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
 332
 333         TP_ARGS(name, state, cpu_id)
 334 );
 335
 336 DEFINE_EVENT(clock, clock_disable,
 337
 338         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
 339
 340         TP_ARGS(name, state, cpu_id)
 341 );
 342
 343 DEFINE_EVENT(clock, clock_set_rate,
 344
 345         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
 346
 347         TP_ARGS(name, state, cpu_id)
 348 );
 349
 350 /*
 351  * The power domain events are used for power domains transitions
 352  */
 353 DECLARE_EVENT_CLASS(power_domain,
 354
 355         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
 356
 357         TP_ARGS(name, state, cpu_id),
 358
 359         TP_STRUCT__entry(
 360                 __string(       name,           name            )
 361                 __field(        u64,            state           )
 362                 __field(        u64,            cpu_id          )
 363         ),
 364
 365         TP_fast_assign(
 366                 __assign_str(name);
 367                 __entry->state = state;
 368                 __entry->cpu_id = cpu_id;
 369 ),
 370
 371         TP_printk("%s state=%lu cpu_id=%lu", __get_str(name),
 372                 (unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
 373 );
 374
 375 DEFINE_EVENT(power_domain, power_domain_target,
 376
 377         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
 378
 379         TP_ARGS(name, state, cpu_id)
 380 );
 381
 382 /*
 383  * CPU latency QoS events used for global CPU latency QoS list updates
 384  */
 385 DECLARE_EVENT_CLASS(cpu_latency_qos_request,
 386
 387         TP_PROTO(s32 value),
 388
 389         TP_ARGS(value),
 390
 391         TP_STRUCT__entry(
 392                 __field( s32,                    value          )
 393         ),
 394
 395         TP_fast_assign(
 396                 __entry->value = value;
 397         ),
 398
 399         TP_printk("CPU_DMA_LATENCY value=%d",
 400                   __entry->value)
 401 );
 402
 403 DEFINE_EVENT(cpu_latency_qos_request, pm_qos_add_request,
 404
 405         TP_PROTO(s32 value),
 406
 407         TP_ARGS(value)
 408 );
 409
 410 DEFINE_EVENT(cpu_latency_qos_request, pm_qos_update_request,
 411
 412         TP_PROTO(s32 value),
 413
 414         TP_ARGS(value)
 415 );
 416
 417 DEFINE_EVENT(cpu_latency_qos_request, pm_qos_remove_request,
 418
 419         TP_PROTO(s32 value),
 420
 421         TP_ARGS(value)
 422 );
 423
 424 /*
 425  * General PM QoS events used for updates of PM QoS request lists
 426  */
 427 DECLARE_EVENT_CLASS(pm_qos_update,
 428
 429         TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
 430
 431         TP_ARGS(action, prev_value, curr_value),
 432
 433         TP_STRUCT__entry(
 434                 __field( enum pm_qos_req_action, action         )
 435                 __field( int,                    prev_value     )
 436                 __field( int,                    curr_value     )
 437         ),
 438
 439         TP_fast_assign(
 440                 __entry->action = action;
 441                 __entry->prev_value = prev_value;
 442                 __entry->curr_value = curr_value;
 443         ),
 444
 445         TP_printk("action=%s prev_value=%d curr_value=%d",
 446                   __print_symbolic(__entry->action,
 447                         { PM_QOS_ADD_REQ,       "ADD_REQ" },
 448                         { PM_QOS_UPDATE_REQ,    "UPDATE_REQ" },
 449                         { PM_QOS_REMOVE_REQ,    "REMOVE_REQ" }),
 450                   __entry->prev_value, __entry->curr_value)
 451 );
 452
 453 DEFINE_EVENT(pm_qos_update, pm_qos_update_target,
 454
 455         TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
 456
 457         TP_ARGS(action, prev_value, curr_value)
 458 );
 459
 460 DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags,
 461
 462         TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
 463
 464         TP_ARGS(action, prev_value, curr_value),
 465
 466         TP_printk("action=%s prev_value=0x%x curr_value=0x%x",
 467                   __print_symbolic(__entry->action,
 468                         { PM_QOS_ADD_REQ,       "ADD_REQ" },
 469                         { PM_QOS_UPDATE_REQ,    "UPDATE_REQ" },
 470                         { PM_QOS_REMOVE_REQ,    "REMOVE_REQ" }),
 471                   __entry->prev_value, __entry->curr_value)
 472 );
 473
 474 DECLARE_EVENT_CLASS(dev_pm_qos_request,
 475
 476         TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
 477                  s32 new_value),
 478
 479         TP_ARGS(name, type, new_value),
 480
 481         TP_STRUCT__entry(
 482                 __string( name,                    name         )
 483                 __field( enum dev_pm_qos_req_type, type         )
 484                 __field( s32,                      new_value    )
 485         ),
 486
 487         TP_fast_assign(
 488                 __assign_str(name);
 489                 __entry->type = type;
 490                 __entry->new_value = new_value;
 491         ),
 492
 493         TP_printk("device=%s type=%s new_value=%d",
 494                   __get_str(name),
 495                   __print_symbolic(__entry->type,
 496                         { DEV_PM_QOS_RESUME_LATENCY, "DEV_PM_QOS_RESUME_LATENCY" },
 497                         { DEV_PM_QOS_FLAGS, "DEV_PM_QOS_FLAGS" }),
 498                   __entry->new_value)
 499 );
 500
 501 DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request,
 502
 503         TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
 504                  s32 new_value),
 505
 506         TP_ARGS(name, type, new_value)
 507 );
 508
 509 DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request,
 510
 511         TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
 512                  s32 new_value),
 513
 514         TP_ARGS(name, type, new_value)
 515 );
 516
 517 DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,
 518
 519         TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
 520                  s32 new_value),
 521
 522         TP_ARGS(name, type, new_value)
 523 );
 524
 525 TRACE_EVENT(guest_halt_poll_ns,
 526
 527         TP_PROTO(bool grow, unsigned int new, unsigned int old),
 528
 529         TP_ARGS(grow, new, old),
 530
 531         TP_STRUCT__entry(
 532                 __field(bool, grow)
 533                 __field(unsigned int, new)
 534                 __field(unsigned int, old)
 535         ),
 536
 537         TP_fast_assign(
 538                 __entry->grow   = grow;
 539                 __entry->new    = new;
 540                 __entry->old    = old;
 541         ),
 542
 543         TP_printk("halt_poll_ns %u (%s %u)",
 544                 __entry->new,
 545                 __entry->grow ? "grow" : "shrink",
 546                 __entry->old)
 547 );
 548
 549 #define trace_guest_halt_poll_ns_grow(new, old) \
 550         trace_guest_halt_poll_ns(true, new, old)
 551 #define trace_guest_halt_poll_ns_shrink(new, old) \
 552         trace_guest_halt_poll_ns(false, new, old)
 553 #endif /* _TRACE_POWER_H */
 554
 555 /* This part must be outside protection */
 556 #include <trace/define_trace.h>