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