linux/include/trace/events/power.h
<<
>>
Prefs
   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
  16DECLARE_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
  36DEFINE_EVENT(cpu, cpu_idle,
  37
  38        TP_PROTO(unsigned int state, unsigned int cpu_id),
  39
  40        TP_ARGS(state, cpu_id)
  41);
  42
  43TRACE_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
  65TRACE_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
 145DEFINE_EVENT(cpu, cpu_frequency,
 146
 147        TP_PROTO(unsigned int frequency, unsigned int cpu_id),
 148
 149        TP_ARGS(frequency, cpu_id)
 150);
 151
 152TRACE_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
 176TRACE_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
 204TRACE_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
 226TRACE_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
 248DECLARE_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
 268DEFINE_EVENT(wakeup_source, wakeup_source_activate,
 269
 270        TP_PROTO(const char *name, unsigned int state),
 271
 272        TP_ARGS(name, state)
 273);
 274
 275DEFINE_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 */
 286DECLARE_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
 308DEFINE_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
 315DEFINE_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
 322DEFINE_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 */
 332DECLARE_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
 354DEFINE_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 */
 364DECLARE_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
 386DEFINE_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
 393DEFINE_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
 400DEFINE_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
 407TRACE_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
 431DECLARE_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
 457DEFINE_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
 464DEFINE_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
 478DECLARE_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
 505DEFINE_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
 513DEFINE_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
 521DEFINE_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>
 532