include/linux/tegra_profiler.h

   1 /*
   2  * include/linux/tegra_profiler.h
   3  *
   4  * Copyright (c) 2014, 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   29
  23 #define QUADD_IO_VERSION        12
  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
  34 #define QUADD_SAMPLE_VERSION_THUMB_MODE_FLAG    17
  35 #define QUADD_SAMPLE_VERSION_GROUP_SAMPLES      18
  36 #define QUADD_SAMPLE_VERSION_THREAD_STATE_FLD   19
  37 #define QUADD_SAMPLE_VERSION_BT_UNWIND_TABLES   22
  38 #define QUADD_SAMPLE_VERSION_SUPPORT_IP64       23
  39 #define QUADD_SAMPLE_VERSION_SPECIAL_MMAP       24
  40 #define QUADD_SAMPLE_VERSION_UNWIND_MIXED       25
  41 #define QUADD_SAMPLE_VERSION_UNW_ENTRY_TYPE     26
  42 #define QUADD_SAMPLE_VERSION_USE_ARCH_TIMER     27
  43 #define QUADD_SAMPLE_VERSION_SCHED_SAMPLES      28
  44 #define QUADD_SAMPLE_VERSION_HDR_UNW_METHOD     29
  45
  46 #define QUADD_MAX_COUNTERS      32
  47 #define QUADD_MAX_PROCESS       64
  48
  49 #define QUADD_DEVICE_NAME       "quadd"
  50 #define QUADD_AUTH_DEVICE_NAME  "quadd_auth"
  51
  52 #define QUADD_MOD_DEVICE_NAME           "quadd_mod"
  53 #define QUADD_MOD_AUTH_DEVICE_NAME      "quadd_mod_auth"
  54
  55 #define QUADD_IOCTL     100
  56
  57 /*
  58  * Setup params (profiling frequency, etc.)
  59  */
  60 #define IOCTL_SETUP _IOW(QUADD_IOCTL, 0, struct quadd_parameters)
  61
  62 /*
  63  * Start profiling.
  64  */
  65 #define IOCTL_START _IO(QUADD_IOCTL, 1)
  66
  67 /*
  68  * Stop profiling.
  69  */
  70 #define IOCTL_STOP _IO(QUADD_IOCTL, 2)
  71
  72 /*
  73  * Getting capabilities
  74  */
  75 #define IOCTL_GET_CAP _IOR(QUADD_IOCTL, 3, struct quadd_comm_cap)
  76
  77 /*
  78  * Getting state of module
  79  */
  80 #define IOCTL_GET_STATE _IOR(QUADD_IOCTL, 4, struct quadd_module_state)
  81
  82 /*
  83  * Getting version of module
  84  */
  85 #define IOCTL_GET_VERSION _IOR(QUADD_IOCTL, 5, struct quadd_module_version)
  86
  87 /*
  88  * Send exception-handling tables info
  89  */
  90 #define IOCTL_SET_EXTAB _IOW(QUADD_IOCTL, 6, struct quadd_extables)
  91
  92 #define QUADD_CPUMODE_TEGRA_POWER_CLUSTER_LP    (1 << 29)       /* LP CPU */
  93 #define QUADD_CPUMODE_THUMB                     (1 << 30)       /* thumb mode */
  94
  95 enum quadd_events_id {
  96         QUADD_EVENT_TYPE_CPU_CYCLES = 0,
  97
  98         QUADD_EVENT_TYPE_INSTRUCTIONS,
  99         QUADD_EVENT_TYPE_BRANCH_INSTRUCTIONS,
 100         QUADD_EVENT_TYPE_BRANCH_MISSES,
 101         QUADD_EVENT_TYPE_BUS_CYCLES,
 102
 103         QUADD_EVENT_TYPE_L1_DCACHE_READ_MISSES,
 104         QUADD_EVENT_TYPE_L1_DCACHE_WRITE_MISSES,
 105         QUADD_EVENT_TYPE_L1_ICACHE_MISSES,
 106
 107         QUADD_EVENT_TYPE_L2_DCACHE_READ_MISSES,
 108         QUADD_EVENT_TYPE_L2_DCACHE_WRITE_MISSES,
 109         QUADD_EVENT_TYPE_L2_ICACHE_MISSES,
 110
 111         QUADD_EVENT_TYPE_MAX,
 112 };
 113
 114 struct event_data {
 115         int event_source;
 116         int event_id;
 117
 118         u32 val;
 119         u32 prev_val;
 120 };
 121
 122 enum quadd_record_type {
 123         QUADD_RECORD_TYPE_SAMPLE = 1,
 124         QUADD_RECORD_TYPE_MMAP,
 125         QUADD_RECORD_TYPE_MA,
 126         QUADD_RECORD_TYPE_COMM,
 127         QUADD_RECORD_TYPE_DEBUG,
 128         QUADD_RECORD_TYPE_HEADER,
 129         QUADD_RECORD_TYPE_POWER_RATE,
 130         QUADD_RECORD_TYPE_ADDITIONAL_SAMPLE,
 131         QUADD_RECORD_TYPE_SCHED,
 132 };
 133
 134 enum quadd_event_source {
 135         QUADD_EVENT_SOURCE_PMU = 1,
 136         QUADD_EVENT_SOURCE_PL310,
 137 };
 138
 139 enum quadd_cpu_mode {
 140         QUADD_CPU_MODE_KERNEL = 1,
 141         QUADD_CPU_MODE_USER,
 142         QUADD_CPU_MODE_NONE,
 143 };
 144
 145 #pragma pack(push, 1)
 146
 147 #define QUADD_SAMPLE_UNW_METHOD_SHIFT   0
 148 #define QUADD_SAMPLE_UNW_METHOD_MASK    (1 << QUADD_SAMPLE_UNW_METHOD_SHIFT)
 149
 150 enum {
 151         QUADD_UNW_METHOD_FP = 0,
 152         QUADD_UNW_METHOD_EHT,
 153         QUADD_UNW_METHOD_MIXED,
 154         QUADD_UNW_METHOD_NONE,
 155 };
 156
 157 #define QUADD_SAMPLE_URC_SHIFT          1
 158 #define QUADD_SAMPLE_URC_MASK           (0x0f << QUADD_SAMPLE_URC_SHIFT)
 159
 160 enum {
 161         QUADD_URC_SUCCESS = 0,
 162         QUADD_URC_FAILURE,
 163         QUADD_URC_IDX_NOT_FOUND,
 164         QUADD_URC_TBL_NOT_EXIST,
 165         QUADD_URC_EACCESS,
 166         QUADD_URC_TBL_IS_CORRUPT,
 167         QUADD_URC_CANTUNWIND,
 168         QUADD_URC_UNHANDLED_INSTRUCTION,
 169         QUADD_URC_REFUSE_TO_UNWIND,
 170         QUADD_URC_SP_INCORRECT,
 171         QUADD_URC_SPARE_ENCODING,
 172         QUADD_URC_UNSUPPORTED_PR,
 173         QUADD_URC_PC_INCORRECT,
 174         QUADD_URC_LEVEL_TOO_DEEP,
 175         QUADD_URC_FP_INCORRECT,
 176         QUADD_URC_MAX,
 177 };
 178
 179 #define QUADD_SED_IP64                  (1 << 0)
 180
 181 #define QUADD_SED_UNW_METHOD_SHIFT      1
 182 #define QUADD_SED_UNW_METHOD_MASK       (0x07 << QUADD_SED_UNW_METHOD_SHIFT)
 183
 184 enum {
 185         QUADD_UNW_TYPE_FP = 0,
 186         QUADD_UNW_TYPE_UT,
 187         QUADD_UNW_TYPE_LR_FP,
 188         QUADD_UNW_TYPE_LR_UT,
 189         QUADD_UNW_TYPE_KCTX,
 190 };
 191
 192 struct quadd_sample_data {
 193         u64 ip;
 194         u32 pid;
 195         u64 time;
 196
 197         u16     cpu:6,
 198                 user_mode:1,
 199                 lp_mode:1,
 200                 thumb_mode:1,
 201                 state:1,
 202                 in_interrupt:1,
 203                 reserved:5;
 204
 205         u8 callchain_nr;
 206         u32 events_flags;
 207 };
 208
 209 #define QUADD_MMAP_ED_IS_FILE_EXISTS    (1 << 0)
 210
 211 struct quadd_mmap_data {
 212         u32 pid;
 213
 214         u64 addr;
 215         u64 len;
 216
 217         u8 user_mode:1;
 218         u16 filename_length;
 219 };
 220
 221 struct quadd_ma_data {
 222         u32 pid;
 223         u64 time;
 224
 225         u32 vm_size;
 226         u32 rss_size;
 227 };
 228
 229 struct quadd_power_rate_data {
 230         u64 time;
 231
 232         u8 nr_cpus;
 233
 234         u32 gpu;
 235         u32 emc;
 236 };
 237
 238 struct quadd_additional_sample {
 239         u8 type;
 240
 241         u32 values[6];
 242         u16 extra_length;
 243 };
 244
 245 struct quadd_sched_data {
 246         u32 pid;
 247         u64 time;
 248
 249         u32     cpu:6,
 250                 lp_mode:1,
 251                 sched_in:1,
 252                 reserved:24;
 253
 254         u32 data[2];
 255 };
 256
 257 enum {
 258         QM_DEBUG_SAMPLE_TYPE_SCHED_IN = 1,
 259         QM_DEBUG_SAMPLE_TYPE_SCHED_OUT,
 260
 261         QM_DEBUG_SAMPLE_TYPE_TIMER_HANDLE,
 262         QM_DEBUG_SAMPLE_TYPE_TIMER_START,
 263         QM_DEBUG_SAMPLE_TYPE_TIMER_CANCEL,
 264         QM_DEBUG_SAMPLE_TYPE_TIMER_FORWARD,
 265
 266         QM_DEBUG_SAMPLE_TYPE_READ_COUNTER,
 267
 268         QM_DEBUG_SAMPLE_TYPE_SOURCE_START,
 269         QM_DEBUG_SAMPLE_TYPE_SOURCE_STOP,
 270 };
 271
 272 struct quadd_debug_data {
 273         u8 type;
 274
 275         u32 pid;
 276         u64 time;
 277
 278         u16     cpu:6,
 279                 user_mode:1,
 280                 lp_mode:1,
 281                 thumb_mode:1,
 282                 reserved:7;
 283
 284         u32 extra_value[2];
 285         u16 extra_length;
 286 };
 287
 288 #define QUADD_HEADER_MAGIC      0x1122
 289
 290 #define QUADD_HDR_UNW_METHOD_SHIFT      0
 291 #define QUADD_HDR_UNW_METHOD_MASK       (0x07 << QUADD_HDR_UNW_METHOD_SHIFT)
 292
 293 struct quadd_header_data {
 294         u16 magic;
 295         u16 version;
 296
 297         u32     backtrace:1,
 298                 use_freq:1,
 299                 system_wide:1,
 300                 power_rate:1,
 301                 debug_samples:1,
 302                 get_mmap:1,
 303                 reserved:26;    /* reserved fields for future extensions */
 304
 305         u32 freq;
 306         u16 ma_freq;
 307         u16 power_rate_freq;
 308
 309         u8 nr_events;
 310         u16 extra_length;
 311 };
 312
 313 struct quadd_record_data {
 314         u8 record_type;
 315
 316         /* sample: it should be the biggest size */
 317         union {
 318                 struct quadd_sample_data        sample;
 319                 struct quadd_mmap_data          mmap;
 320                 struct quadd_ma_data            ma;
 321                 struct quadd_debug_data         debug;
 322                 struct quadd_header_data        hdr;
 323                 struct quadd_power_rate_data    power_rate;
 324                 struct quadd_sched_data         sched;
 325                 struct quadd_additional_sample  additional_sample;
 326         };
 327 } __aligned(4);
 328
 329 #pragma pack(4)
 330
 331 #define QUADD_MAX_PACKAGE_NAME  320
 332
 333 enum {
 334         QUADD_PARAM_IDX_SIZE_OF_RB      = 0,
 335         QUADD_PARAM_IDX_EXTRA           = 1,
 336 };
 337
 338 #define QUADD_PARAM_EXTRA_GET_MMAP              (1 << 0)
 339 #define QUADD_PARAM_EXTRA_BT_FP                 (1 << 1)
 340 #define QUADD_PARAM_EXTRA_BT_UNWIND_TABLES      (1 << 2)
 341 #define QUADD_PARAM_EXTRA_BT_MIXED              (1 << 3)
 342
 343 struct quadd_parameters {
 344         u32 freq;
 345         u32 ma_freq;
 346         u32 power_rate_freq;
 347
 348         u64     backtrace:1,
 349                 use_freq:1,
 350                 system_wide:1,
 351                 debug_samples:1;
 352
 353         u32 pids[QUADD_MAX_PROCESS];
 354         u32 nr_pids;
 355
 356         u8 package_name[QUADD_MAX_PACKAGE_NAME];
 357
 358         u32 events[QUADD_MAX_COUNTERS];
 359         u32 nr_events;
 360
 361         u32 reserved[16];       /* reserved fields for future extensions */
 362 };
 363
 364 struct quadd_events_cap {
 365         u32     cpu_cycles:1,
 366                 instructions:1,
 367                 branch_instructions:1,
 368                 branch_misses:1,
 369                 bus_cycles:1,
 370
 371                 l1_dcache_read_misses:1,
 372                 l1_dcache_write_misses:1,
 373                 l1_icache_misses:1,
 374
 375                 l2_dcache_read_misses:1,
 376                 l2_dcache_write_misses:1,
 377                 l2_icache_misses:1;
 378 };
 379
 380 enum {
 381         QUADD_COMM_CAP_IDX_EXTRA = 0,
 382 };
 383
 384 #define QUADD_COMM_CAP_EXTRA_BT_KERNEL_CTX      (1 << 0)
 385 #define QUADD_COMM_CAP_EXTRA_GET_MMAP           (1 << 1)
 386 #define QUADD_COMM_CAP_EXTRA_GROUP_SAMPLES      (1 << 2)
 387 #define QUADD_COMM_CAP_EXTRA_BT_UNWIND_TABLES   (1 << 3)
 388 #define QUADD_COMM_CAP_EXTRA_SUPPORT_AARCH64    (1 << 4)
 389 #define QUADD_COMM_CAP_EXTRA_SPECIAL_ARCH_MMAP  (1 << 5)
 390 #define QUADD_COMM_CAP_EXTRA_UNWIND_MIXED       (1 << 6)
 391 #define QUADD_COMM_CAP_EXTRA_UNW_ENTRY_TYPE     (1 << 7)
 392 #define QUADD_COMM_CAP_EXTRA_USE_ARCH_TIMER     (1 << 8)
 393
 394 struct quadd_comm_cap {
 395         u32     pmu:1,
 396                 power_rate:1,
 397                 l2_cache:1,
 398                 l2_multiple_events:1,
 399                 tegra_lp_cluster:1,
 400                 blocked_read:1;
 401
 402         struct quadd_events_cap events_cap;
 403
 404         u32 reserved[16];       /* reserved fields for future extensions */
 405 };
 406
 407 enum {
 408         QUADD_MOD_STATE_IDX_RB_MAX_FILL_COUNT = 0,
 409         QUADD_MOD_STATE_IDX_STATUS,
 410 };
 411
 412 #define QUADD_MOD_STATE_STATUS_IS_ACTIVE        (1 << 0)
 413 #define QUADD_MOD_STATE_STATUS_IS_AUTH_OPEN     (1 << 1)
 414
 415 struct quadd_module_state {
 416         u64 nr_all_samples;
 417         u64 nr_skipped_samples;
 418
 419         u32 buffer_size;
 420         u32 buffer_fill_size;
 421
 422         u32 reserved[16];       /* reserved fields for future extensions */
 423 };
 424
 425 struct quadd_module_version {
 426         u8 branch[32];
 427         u8 version[16];
 428
 429         u32 samples_version;
 430         u32 io_version;
 431
 432         u32 reserved[4];        /* reserved fields for future extensions */
 433 };
 434
 435 struct quadd_sec_info {
 436         u64 addr;
 437         u64 length;
 438 };
 439
 440 enum {
 441         QUADD_EXT_IDX_EXTAB_OFFSET = 0,
 442         QUADD_EXT_IDX_EXIDX_OFFSET = 1,
 443         QUADD_EXT_IDX_MMAP_VM_START = 2,
 444 };
 445
 446 struct quadd_extables {
 447         u64 vm_start;
 448         u64 vm_end;
 449
 450         struct quadd_sec_info extab;
 451         struct quadd_sec_info exidx;
 452
 453         u32 reserved[4];        /* reserved fields for future extensions */
 454 };
 455
 456 #pragma pack(pop)
 457
 458 #ifdef __KERNEL__
 459
 460 struct task_struct;
 461 struct vm_area_struct;
 462
 463 #ifdef CONFIG_TEGRA_PROFILER
 464 extern void __quadd_task_sched_in(struct task_struct *prev,
 465                                   struct task_struct *task);
 466 extern void __quadd_task_sched_out(struct task_struct *prev,
 467                                    struct task_struct *next);
 468
 469 extern void __quadd_event_mmap(struct vm_area_struct *vma);
 470
 471 static inline void quadd_task_sched_in(struct task_struct *prev,
 472                                        struct task_struct *task)
 473 {
 474         __quadd_task_sched_in(prev, task);
 475 }
 476
 477 static inline void quadd_task_sched_out(struct task_struct *prev,
 478                                         struct task_struct *next)
 479 {
 480         __quadd_task_sched_out(prev, next);
 481 }
 482
 483 static inline void quadd_event_mmap(struct vm_area_struct *vma)
 484 {
 485         __quadd_event_mmap(vma);
 486 }
 487
 488 #else   /* CONFIG_TEGRA_PROFILER */
 489
 490 static inline void quadd_task_sched_in(struct task_struct *prev,
 491                                        struct task_struct *task)
 492 {
 493 }
 494
 495 static inline void quadd_task_sched_out(struct task_struct *prev,
 496                                         struct task_struct *next)
 497 {
 498 }
 499
 500 static inline void quadd_event_mmap(struct vm_area_struct *vma)
 501 {
 502 }
 503
 504 #endif  /* CONFIG_TEGRA_PROFILER */
 505
 506 #endif  /* __KERNEL__ */
 507
 508 #endif  /* __TEGRA_PROFILER_H */