include/linux/tegra_profiler.h

   1 /*
   2  * include/linux/tegra_profiler.h
   3  *
   4  * Copyright (c) 2013-2016, NVIDIA CORPORATION.  All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  */
  16
  17 #ifndef __TEGRA_PROFILER_H
  18 #define __TEGRA_PROFILER_H
  19
  20 #include <linux/ioctl.h>
  21
  22 #define QUADD_SAMPLES_VERSION   36
  23 #define QUADD_IO_VERSION        20
  24
  25 #define QUADD_IO_VERSION_DYNAMIC_RB             5
  26 #define QUADD_IO_VERSION_RB_MAX_FILL_COUNT      6
  27 #define QUADD_IO_VERSION_MOD_STATE_STATUS_FIELD 7
  28 #define QUADD_IO_VERSION_BT_KERNEL_CTX          8
  29 #define QUADD_IO_VERSION_GET_MMAP               9
  30 #define QUADD_IO_VERSION_BT_UNWIND_TABLES       10
  31 #define QUADD_IO_VERSION_UNWIND_MIXED           11
  32 #define QUADD_IO_VERSION_EXTABLES_MMAP          12
  33 #define QUADD_IO_VERSION_ARCH_TIMER_OPT         13
  34 #define QUADD_IO_VERSION_DATA_MMAP              14
  35 #define QUADD_IO_VERSION_BT_LOWER_BOUND         15
  36 #define QUADD_IO_VERSION_STACK_OFFSET           16
  37 #define QUADD_IO_VERSION_SECTIONS_INFO          17
  38 #define QUADD_IO_VERSION_UNW_METHODS_OPT        18
  39 #define QUADD_IO_VERSION_PER_CPU_SETUP          19
  40 #define QUADD_IO_VERSION_TRACE_ALL_TASKS        20
  41
  42 #define QUADD_SAMPLE_VERSION_THUMB_MODE_FLAG    17
  43 #define QUADD_SAMPLE_VERSION_GROUP_SAMPLES      18
  44 #define QUADD_SAMPLE_VERSION_THREAD_STATE_FLD   19
  45 #define QUADD_SAMPLE_VERSION_BT_UNWIND_TABLES   22
  46 #define QUADD_SAMPLE_VERSION_SUPPORT_IP64       23
  47 #define QUADD_SAMPLE_VERSION_SPECIAL_MMAP       24
  48 #define QUADD_SAMPLE_VERSION_UNWIND_MIXED       25
  49 #define QUADD_SAMPLE_VERSION_UNW_ENTRY_TYPE     26
  50 #define QUADD_SAMPLE_VERSION_USE_ARCH_TIMER     27
  51 #define QUADD_SAMPLE_VERSION_SCHED_SAMPLES      28
  52 #define QUADD_SAMPLE_VERSION_HDR_UNW_METHOD     29
  53 #define QUADD_SAMPLE_VERSION_HDR_ARCH_TIMER     30
  54 #define QUADD_SAMPLE_VERSION_STACK_OFFSET       31
  55 #define QUADD_SAMPLE_VERSION_SCHED_TASK_STATE   32
  56 #define QUADD_SAMPLE_VERSION_URCS               33
  57 #define QUADD_SAMPLE_VERSION_HOTPLUG            34
  58 #define QUADD_SAMPLE_VERSION_PER_CPU_SETUP      35
  59 #define QUADD_SAMPLE_VERSION_REPORT_TGID        36
  60
  61 #define QUADD_MMAP_HEADER_VERSION               1
  62
  63 #define QUADD_MAX_COUNTERS      32
  64 #define QUADD_MAX_PROCESS       64
  65
  66 #define QUADD_DEVICE_NAME       "quadd"
  67 #define QUADD_AUTH_DEVICE_NAME  "quadd_auth"
  68
  69 #define QUADD_MOD_DEVICE_NAME           "quadd_mod"
  70 #define QUADD_MOD_AUTH_DEVICE_NAME      "quadd_mod_auth"
  71
  72 #define QUADD_IOCTL     100
  73
  74 /*
  75  * Setup params (profiling frequency, etc.)
  76  */
  77 #define IOCTL_SETUP _IOW(QUADD_IOCTL, 0, struct quadd_parameters)
  78
  79 /*
  80  * Start profiling.
  81  */
  82 #define IOCTL_START _IO(QUADD_IOCTL, 1)
  83
  84 /*
  85  * Stop profiling.
  86  */
  87 #define IOCTL_STOP _IO(QUADD_IOCTL, 2)
  88
  89 /*
  90  * Getting capabilities
  91  */
  92 #define IOCTL_GET_CAP _IOR(QUADD_IOCTL, 3, struct quadd_comm_cap)
  93
  94 /*
  95  * Getting state of module
  96  */
  97 #define IOCTL_GET_STATE _IOR(QUADD_IOCTL, 4, struct quadd_module_state)
  98
  99 /*
 100  * Getting version of module
 101  */
 102 #define IOCTL_GET_VERSION _IOR(QUADD_IOCTL, 5, struct quadd_module_version)
 103
 104 /*
 105  * Send exception-handling tables info
 106  * This ioctl is obsolete
 107  */
 108 /*#define IOCTL_SET_EXTAB _IOW(QUADD_IOCTL, 6, struct quadd_extables)*/
 109
 110 /*
 111  * Send ring buffer mmap info
 112  */
 113 #define IOCTL_SET_MMAP_RB _IOW(QUADD_IOCTL, 7, struct quadd_mmap_rb_info)
 114
 115 /*
 116  * Send sections info
 117  */
 118 #define IOCTL_SET_SECTIONS_INFO _IOW(QUADD_IOCTL, 8, struct quadd_sections)
 119
 120 /*
 121  * Per CPU PMU setup
 122  */
 123 #define IOCTL_SETUP_PMU_FOR_CPU _IOW(QUADD_IOCTL, 9,\
 124                                      struct quadd_pmu_setup_for_cpu)
 125
 126 /*
 127  * Per CPU capabilities
 128  */
 129 #define IOCTL_GET_CAP_FOR_CPU _IOWR(QUADD_IOCTL, 10,\
 130                                     struct quadd_comm_cap_for_cpu)
 131
 132
 133
 134 #define QUADD_CPUMODE_TEGRA_POWER_CLUSTER_LP    (1 << 29)       /* LP CPU */
 135 #define QUADD_CPUMODE_THUMB                     (1 << 30)       /* thumb mode */
 136
 137 enum quadd_events_id {
 138         QUADD_EVENT_TYPE_CPU_CYCLES = 0,
 139
 140         QUADD_EVENT_TYPE_INSTRUCTIONS,
 141         QUADD_EVENT_TYPE_BRANCH_INSTRUCTIONS,
 142         QUADD_EVENT_TYPE_BRANCH_MISSES,
 143         QUADD_EVENT_TYPE_BUS_CYCLES,
 144
 145         QUADD_EVENT_TYPE_L1_DCACHE_READ_MISSES,
 146         QUADD_EVENT_TYPE_L1_DCACHE_WRITE_MISSES,
 147         QUADD_EVENT_TYPE_L1_ICACHE_MISSES,
 148
 149         QUADD_EVENT_TYPE_L2_DCACHE_READ_MISSES,
 150         QUADD_EVENT_TYPE_L2_DCACHE_WRITE_MISSES,
 151         QUADD_EVENT_TYPE_L2_ICACHE_MISSES,
 152
 153         QUADD_EVENT_TYPE_MAX,
 154 };
 155
 156 struct event_data {
 157         int event_source;
 158         int event_id;
 159
 160         u32 val;
 161         u32 prev_val;
 162 };
 163
 164 enum quadd_record_type {
 165         QUADD_RECORD_TYPE_SAMPLE = 1,
 166         QUADD_RECORD_TYPE_MMAP,
 167         QUADD_RECORD_TYPE_MA,
 168         QUADD_RECORD_TYPE_COMM,
 169         QUADD_RECORD_TYPE_DEBUG,
 170         QUADD_RECORD_TYPE_HEADER,
 171         QUADD_RECORD_TYPE_POWER_RATE,
 172         QUADD_RECORD_TYPE_ADDITIONAL_SAMPLE,
 173         QUADD_RECORD_TYPE_SCHED,
 174         QUADD_RECORD_TYPE_HOTPLUG,
 175 };
 176
 177 enum quadd_event_source {
 178         QUADD_EVENT_SOURCE_PMU = 1,
 179         QUADD_EVENT_SOURCE_PL310,
 180 };
 181
 182 enum quadd_cpu_mode {
 183         QUADD_CPU_MODE_KERNEL = 1,
 184         QUADD_CPU_MODE_USER,
 185         QUADD_CPU_MODE_NONE,
 186 };
 187
 188 #pragma pack(push, 1)
 189
 190 #define QUADD_SAMPLE_RES_URCS_ENABLED   (1 << 0)
 191
 192 #define QUADD_SAMPLE_URC_MASK           0xff
 193
 194 #define QUADD_SAMPLE_URC_SHIFT_FP       0
 195 #define QUADD_SAMPLE_URC_SHIFT_UT       (1 * 8)
 196 #define QUADD_SAMPLE_URC_SHIFT_DWARF    (2 * 8)
 197
 198 enum {
 199         QUADD_URC_SUCCESS = 0,
 200         QUADD_URC_FAILURE,
 201         QUADD_URC_IDX_NOT_FOUND,
 202         QUADD_URC_TBL_NOT_EXIST,
 203         QUADD_URC_EACCESS,
 204         QUADD_URC_TBL_IS_CORRUPT,
 205         QUADD_URC_CANTUNWIND,
 206         QUADD_URC_UNHANDLED_INSTRUCTION,
 207         QUADD_URC_REFUSE_TO_UNWIND,
 208         QUADD_URC_SP_INCORRECT,
 209         QUADD_URC_SPARE_ENCODING,
 210         QUADD_URC_UNSUPPORTED_PR,
 211         QUADD_URC_PC_INCORRECT,
 212         QUADD_URC_LEVEL_TOO_DEEP,
 213         QUADD_URC_FP_INCORRECT,
 214         QUADD_URC_NONE,
 215         QUADD_URC_UNWIND_MISMATCH,
 216         QUADD_URC_TBL_LINK_INCORRECT,
 217         QUADD_URC_MAX,
 218 };
 219
 220 #define QUADD_SED_IP64                  (1 << 0)
 221
 222 #define QUADD_SED_STACK_OFFSET_SHIFT    1
 223 #define QUADD_SED_STACK_OFFSET_MASK     (0xffff << QUADD_SED_STACK_OFFSET_SHIFT)
 224
 225 enum {
 226         QUADD_UNW_TYPE_FP = 0,
 227         QUADD_UNW_TYPE_UT,
 228         QUADD_UNW_TYPE_LR_FP,
 229         QUADD_UNW_TYPE_LR_UT,
 230         QUADD_UNW_TYPE_KCTX,
 231         QUADD_UNW_TYPE_DWARF_EH,
 232         QUADD_UNW_TYPE_DWARF_DF,
 233 };
 234
 235 struct quadd_sample_data {
 236         u64 ip;
 237         u32 pid;
 238         u32 tgid;
 239         u64 time;
 240
 241         u16     cpu:6,
 242                 user_mode:1,
 243                 lp_mode:1,
 244                 thumb_mode:1,
 245                 state:1,
 246                 in_interrupt:1,
 247                 reserved:5;
 248
 249         u8 callchain_nr;
 250         u32 events_flags;
 251 };
 252
 253 #define QUADD_MMAP_ED_IS_FILE_EXISTS    (1 << 0)
 254
 255 struct quadd_mmap_data {
 256         u32 pid;
 257
 258         u64 addr;
 259         u64 len;
 260
 261         u8 user_mode:1;
 262         u16 filename_length;
 263 };
 264
 265 struct quadd_ma_data {
 266         u32 pid;
 267         u64 time;
 268
 269         u32 vm_size;
 270         u32 rss_size;
 271 };
 272
 273 struct quadd_power_rate_data {
 274         u64 time;
 275
 276         u8 nr_cpus;
 277
 278         u32 gpu;
 279         u32 emc;
 280 };
 281
 282 struct quadd_hotplug_data {
 283         u64 time;
 284         u32 cpu;
 285
 286         u32 is_online:1,
 287             reserved:31;
 288 };
 289
 290 struct quadd_additional_sample {
 291         u8 type;
 292
 293         u32 values[6];
 294         u16 extra_length;
 295 };
 296
 297 enum {
 298         QUADD_SCHED_IDX_TASK_STATE = 0,
 299         QUADD_SCHED_IDX_RESERVED,
 300 };
 301
 302 struct quadd_sched_data {
 303         u32 pid;
 304         u32 tgid;
 305         u64 time;
 306
 307         u32     cpu:6,
 308                 lp_mode:1,
 309                 sched_in:1,
 310                 reserved:24;
 311
 312         u32 data[2];
 313 };
 314
 315 enum {
 316         QM_DEBUG_SAMPLE_TYPE_SCHED_IN = 1,
 317         QM_DEBUG_SAMPLE_TYPE_SCHED_OUT,
 318
 319         QM_DEBUG_SAMPLE_TYPE_TIMER_HANDLE,
 320         QM_DEBUG_SAMPLE_TYPE_TIMER_START,
 321         QM_DEBUG_SAMPLE_TYPE_TIMER_CANCEL,
 322         QM_DEBUG_SAMPLE_TYPE_TIMER_FORWARD,
 323
 324         QM_DEBUG_SAMPLE_TYPE_READ_COUNTER,
 325
 326         QM_DEBUG_SAMPLE_TYPE_SOURCE_START,
 327         QM_DEBUG_SAMPLE_TYPE_SOURCE_STOP,
 328 };
 329
 330 struct quadd_debug_data {
 331         u8 type;
 332
 333         u32 pid;
 334         u64 time;
 335
 336         u16     cpu:6,
 337                 user_mode:1,
 338                 lp_mode:1,
 339                 thumb_mode:1,
 340                 reserved:7;
 341
 342         u32 extra_value[2];
 343         u16 extra_length;
 344 };
 345
 346 #define QUADD_HEADER_MAGIC      0x1122
 347
 348 #define QUADD_HDR_BT_FP                 (1 << 0)
 349 #define QUADD_HDR_BT_UT                 (1 << 1)
 350 #define QUADD_HDR_BT_UT_CE              (1 << 2)
 351 #define QUADD_HDR_USE_ARCH_TIMER        (1 << 3)
 352 #define QUADD_HDR_STACK_OFFSET          (1 << 4)
 353 #define QUADD_HDR_BT_DWARF              (1 << 5)
 354 #define QUADD_HDR_HAS_CPUID             (1 << 6)
 355
 356 struct quadd_header_data {
 357         u16 magic;
 358         u16 version;
 359
 360         u32     backtrace:1,
 361                 use_freq:1,
 362                 system_wide:1,
 363                 power_rate:1,
 364                 debug_samples:1,
 365                 get_mmap:1,
 366                 reserved:26;    /* reserved fields for future extensions */
 367
 368         u32 freq;
 369         u16 ma_freq;
 370         u16 power_rate_freq;
 371
 372         u8 nr_events;
 373         u16 extra_length;
 374 };
 375
 376 struct quadd_record_data {
 377         u8 record_type;
 378
 379         /* sample: it should be the biggest size */
 380         union {
 381                 struct quadd_sample_data        sample;
 382                 struct quadd_mmap_data          mmap;
 383                 struct quadd_ma_data            ma;
 384                 struct quadd_debug_data         debug;
 385                 struct quadd_header_data        hdr;
 386                 struct quadd_power_rate_data    power_rate;
 387                 struct quadd_hotplug_data       hotplug;
 388                 struct quadd_sched_data         sched;
 389                 struct quadd_additional_sample  additional_sample;
 390         };
 391 } __aligned(4);
 392
 393 #pragma pack(4)
 394
 395 #define QUADD_MAX_PACKAGE_NAME  320
 396
 397 enum {
 398         QUADD_PARAM_IDX_SIZE_OF_RB      = 0,
 399         QUADD_PARAM_IDX_EXTRA           = 1,
 400         QUADD_PARAM_IDX_BT_LOWER_BOUND  = 2,
 401 };
 402
 403 #define QUADD_PARAM_EXTRA_GET_MMAP              (1 << 0)
 404 #define QUADD_PARAM_EXTRA_BT_FP                 (1 << 1)
 405 #define QUADD_PARAM_EXTRA_BT_UT                 (1 << 2)
 406 #define QUADD_PARAM_EXTRA_BT_MIXED              (1 << 3)
 407 #define QUADD_PARAM_EXTRA_USE_ARCH_TIMER        (1 << 4)
 408 #define QUADD_PARAM_EXTRA_STACK_OFFSET          (1 << 5)
 409 #define QUADD_PARAM_EXTRA_BT_UT_CE              (1 << 6)
 410 #define QUADD_PARAM_EXTRA_BT_DWARF              (1 << 7)
 411 #define QUADD_PARAM_EXTRA_PER_PMU_SETUP         (1 << 8)
 412
 413 struct quadd_parameters {
 414         u32 freq;
 415         u32 ma_freq;
 416         u32 power_rate_freq;
 417
 418         u64     backtrace:1,
 419                 use_freq:1,
 420                 system_wide:1,
 421                 debug_samples:1,
 422                 trace_all_tasks:1;
 423
 424         u32 pids[QUADD_MAX_PROCESS];
 425         u32 nr_pids;
 426
 427         u8 package_name[QUADD_MAX_PACKAGE_NAME];
 428
 429         u32 events[QUADD_MAX_COUNTERS];
 430         u32 nr_events;
 431
 432         u32 reserved[16];       /* reserved fields for future extensions */
 433 };
 434
 435 struct quadd_pmu_setup_for_cpu {
 436         u32 cpuid;
 437         u32 events[QUADD_MAX_COUNTERS];
 438         u32 nr_events;
 439
 440         u32 reserved[16];
 441 };
 442
 443 struct quadd_events_cap {
 444         u32     cpu_cycles:1,
 445                 instructions:1,
 446                 branch_instructions:1,
 447                 branch_misses:1,
 448                 bus_cycles:1,
 449
 450                 l1_dcache_read_misses:1,
 451                 l1_dcache_write_misses:1,
 452                 l1_icache_misses:1,
 453
 454                 l2_dcache_read_misses:1,
 455                 l2_dcache_write_misses:1,
 456                 l2_icache_misses:1;
 457 };
 458
 459 enum {
 460         QUADD_COMM_CAP_IDX_EXTRA = 0,
 461         QUADD_COMM_CAP_IDX_CPU_MASK = 1,
 462 };
 463
 464 #define QUADD_COMM_CAP_EXTRA_BT_KERNEL_CTX      (1 << 0)
 465 #define QUADD_COMM_CAP_EXTRA_GET_MMAP           (1 << 1)
 466 #define QUADD_COMM_CAP_EXTRA_GROUP_SAMPLES      (1 << 2)
 467 #define QUADD_COMM_CAP_EXTRA_BT_UNWIND_TABLES   (1 << 3)
 468 #define QUADD_COMM_CAP_EXTRA_SUPPORT_AARCH64    (1 << 4)
 469 #define QUADD_COMM_CAP_EXTRA_SPECIAL_ARCH_MMAP  (1 << 5)
 470 #define QUADD_COMM_CAP_EXTRA_UNWIND_MIXED       (1 << 6)
 471 #define QUADD_COMM_CAP_EXTRA_UNW_ENTRY_TYPE     (1 << 7)
 472 #define QUADD_COMM_CAP_EXTRA_ARCH_TIMER         (1 << 8)
 473 #define QUADD_COMM_CAP_EXTRA_RB_MMAP_OP         (1 << 9)
 474 #define QUADD_COMM_CAP_EXTRA_CPU_MASK           (1 << 10)
 475
 476 struct quadd_comm_cap {
 477         u32     pmu:1,
 478                 power_rate:1,
 479                 l2_cache:1,
 480                 l2_multiple_events:1,
 481                 tegra_lp_cluster:1,
 482                 blocked_read:1;
 483
 484         struct quadd_events_cap events_cap; /* Deprecated. */
 485
 486         u32 reserved[16];       /* reserved fields for future extensions */
 487 };
 488
 489 struct quadd_comm_cap_for_cpu {
 490         u32     l2_cache:1,
 491                 l2_multiple_events:1;
 492         int cpuid;
 493         struct quadd_events_cap events_cap;
 494 };
 495
 496 enum {
 497         QUADD_MOD_STATE_IDX_RB_MAX_FILL_COUNT = 0,
 498         QUADD_MOD_STATE_IDX_STATUS,
 499 };
 500
 501 #define QUADD_MOD_STATE_STATUS_IS_ACTIVE        (1 << 0)
 502 #define QUADD_MOD_STATE_STATUS_IS_AUTH_OPEN     (1 << 1)
 503
 504 struct quadd_module_state {
 505         u64 nr_all_samples;
 506         u64 nr_skipped_samples;
 507
 508         u32 buffer_size;
 509         u32 buffer_fill_size;
 510
 511         u32 reserved[16];       /* reserved fields for future extensions */
 512 };
 513
 514 struct quadd_module_version {
 515         u8 branch[32];
 516         u8 version[16];
 517
 518         u32 samples_version;
 519         u32 io_version;
 520
 521         u32 reserved[4];        /* reserved fields for future extensions */
 522 };
 523
 524 enum {
 525         QUADD_SEC_TYPE_EXTAB = 0,
 526         QUADD_SEC_TYPE_EXIDX,
 527
 528         QUADD_SEC_TYPE_EH_FRAME,
 529         QUADD_SEC_TYPE_EH_FRAME_HDR,
 530
 531         QUADD_SEC_TYPE_DEBUG_FRAME,
 532         QUADD_SEC_TYPE_DEBUG_FRAME_HDR,
 533
 534         QUADD_SEC_TYPE_MAX,
 535 };
 536
 537 struct quadd_sec_info {
 538         u64 addr;
 539         u64 length;
 540
 541         u64 mmap_offset;
 542 };
 543
 544 struct quadd_sections {
 545         u64 vm_start;
 546         u64 vm_end;
 547
 548         struct quadd_sec_info sec[QUADD_SEC_TYPE_MAX];
 549
 550         u64 user_mmap_start;
 551
 552         u64 reserved[4];        /* reserved fields for future extensions */
 553 };
 554
 555 struct quadd_mmap_rb_info {
 556         u32 cpu_id;
 557
 558         u64 vm_start;
 559         u64 vm_end;
 560
 561         u32 reserved[4];        /* reserved fields for future extensions */
 562 };
 563
 564 #define QUADD_MMAP_HEADER_MAGIC         0x33445566
 565
 566 struct quadd_mmap_header {
 567         u32 magic;
 568         u32 version;
 569
 570         u32 cpu_id;
 571         u32 samples_version;
 572
 573         u32 reserved[4];        /* reserved fields for future extensions */
 574 } __aligned(8);
 575
 576 enum {
 577         QUADD_RB_STATE_NONE = 0,
 578         QUADD_RB_STATE_ACTIVE,
 579         QUADD_RB_STATE_STOPPED,
 580 };
 581
 582 struct quadd_ring_buffer_hdr {
 583         u32 state;
 584         u32 size;
 585
 586         u32 pos_read;
 587         u32 pos_write;
 588
 589         u32 max_fill_count;
 590         u32 skipped_samples;
 591
 592         u32 reserved[4];        /* reserved fields for future extensions */
 593 } __aligned(8);
 594
 595 #pragma pack(pop)
 596
 597 #ifdef __KERNEL__
 598
 599 struct task_struct;
 600 struct vm_area_struct;
 601
 602 #ifdef CONFIG_TEGRA_PROFILER
 603 extern void __quadd_task_sched_in(struct task_struct *prev,
 604                                   struct task_struct *task);
 605 extern void __quadd_task_sched_out(struct task_struct *prev,
 606                                    struct task_struct *next);
 607
 608 extern void __quadd_event_mmap(struct vm_area_struct *vma);
 609
 610 static inline void quadd_task_sched_in(struct task_struct *prev,
 611                                        struct task_struct *task)
 612 {
 613         __quadd_task_sched_in(prev, task);
 614 }
 615
 616 static inline void quadd_task_sched_out(struct task_struct *prev,
 617                                         struct task_struct *next)
 618 {
 619         __quadd_task_sched_out(prev, next);
 620 }
 621
 622 static inline void quadd_event_mmap(struct vm_area_struct *vma)
 623 {
 624         __quadd_event_mmap(vma);
 625 }
 626
 627 #else   /* CONFIG_TEGRA_PROFILER */
 628
 629 static inline void quadd_task_sched_in(struct task_struct *prev,
 630                                        struct task_struct *task)
 631 {
 632 }
 633
 634 static inline void quadd_task_sched_out(struct task_struct *prev,
 635                                         struct task_struct *next)
 636 {
 637 }
 638
 639 static inline void quadd_event_mmap(struct vm_area_struct *vma)
 640 {
 641 }
 642
 643 #endif  /* CONFIG_TEGRA_PROFILER */
 644
 645 #endif  /* __KERNEL__ */
 646
 647 #endif  /* __TEGRA_PROFILER_H */