drivers/platform/x86/intel_telemetry_debugfs.c

   1 /*
   2  * Intel SOC Telemetry debugfs Driver: Currently supports APL
   3  * Copyright (c) 2015, Intel Corporation.
   4  * 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  * This file provides the debugfs interfaces for telemetry.
  16  * /sys/kernel/debug/telemetry/pss_info: Shows Primary Control Sub-Sys Counters
  17  * /sys/kernel/debug/telemetry/ioss_info: Shows IO Sub-System Counters
  18  * /sys/kernel/debug/telemetry/soc_states: Shows SoC State
  19  * /sys/kernel/debug/telemetry/pss_trace_verbosity: Read and Change Tracing
  20  *                              Verbosity via firmware
  21  * /sys/kernel/debug/telemetry/ioss_race_verbosity: Write and Change Tracing
  22  *                              Verbosity via firmware
  23  */
  24 #include <linux/module.h>
  25 #include <linux/init.h>
  26 #include <linux/device.h>
  27 #include <linux/debugfs.h>
  28 #include <linux/seq_file.h>
  29 #include <linux/io.h>
  30 #include <linux/uaccess.h>
  31 #include <linux/pci.h>
  32 #include <linux/suspend.h>
  33
  34 #include <asm/cpu_device_id.h>
  35 #include <asm/intel_pmc_ipc.h>
  36 #include <asm/intel_punit_ipc.h>
  37 #include <asm/intel_telemetry.h>
  38
  39 #define DRIVER_NAME     "telemetry_soc_debugfs"
  40 #define DRIVER_VERSION  "1.0.0"
  41
  42 /* ApolloLake SoC Event-IDs */
  43 #define TELEM_APL_PSS_PSTATES_ID        0x2802
  44 #define TELEM_APL_PSS_IDLE_ID           0x2806
  45 #define TELEM_APL_PCS_IDLE_BLOCKED_ID   0x2C00
  46 #define TELEM_APL_PCS_S0IX_BLOCKED_ID   0x2C01
  47 #define TELEM_APL_PSS_WAKEUP_ID         0x2C02
  48 #define TELEM_APL_PSS_LTR_BLOCKING_ID   0x2C03
  49
  50 #define TELEM_APL_S0IX_TOTAL_OCC_ID     0x4000
  51 #define TELEM_APL_S0IX_SHLW_OCC_ID      0x4001
  52 #define TELEM_APL_S0IX_DEEP_OCC_ID      0x4002
  53 #define TELEM_APL_S0IX_TOTAL_RES_ID     0x4800
  54 #define TELEM_APL_S0IX_SHLW_RES_ID      0x4801
  55 #define TELEM_APL_S0IX_DEEP_RES_ID      0x4802
  56 #define TELEM_APL_D0IX_ID               0x581A
  57 #define TELEM_APL_D3_ID                 0x5819
  58 #define TELEM_APL_PG_ID                 0x5818
  59
  60 #define TELEM_INFO_SRAMEVTS_MASK        0xFF00
  61 #define TELEM_INFO_SRAMEVTS_SHIFT       0x8
  62 #define TELEM_SSRAM_READ_TIMEOUT        10
  63
  64 #define TELEM_MASK_BIT                  1
  65 #define TELEM_MASK_BYTE                 0xFF
  66 #define BYTES_PER_LONG                  8
  67 #define TELEM_APL_MASK_PCS_STATE        0xF
  68
  69 /* Max events in bitmap to check for */
  70 #define TELEM_PSS_IDLE_EVTS             25
  71 #define TELEM_PSS_IDLE_BLOCKED_EVTS     20
  72 #define TELEM_PSS_S0IX_BLOCKED_EVTS     20
  73 #define TELEM_PSS_S0IX_WAKEUP_EVTS      20
  74 #define TELEM_PSS_LTR_BLOCKING_EVTS     20
  75 #define TELEM_IOSS_DX_D0IX_EVTS         25
  76 #define TELEM_IOSS_PG_EVTS              30
  77
  78 #define TELEM_EVT_LEN(x) (sizeof(x)/sizeof((x)[0]))
  79
  80 #define TELEM_DEBUGFS_CPU(model, data) \
  81         { X86_VENDOR_INTEL, 6, model, X86_FEATURE_MWAIT, (unsigned long)&data}
  82
  83 #define TELEM_CHECK_AND_PARSE_EVTS(EVTID, EVTNUM, BUF, EVTLOG, EVTDAT, MASK) { \
  84         if (evtlog[index].telem_evtid == (EVTID)) { \
  85                 for (idx = 0; idx < (EVTNUM); idx++) \
  86                         (BUF)[idx] = ((EVTLOG) >> (EVTDAT)[idx].bit_pos) & \
  87                                      (MASK); \
  88         continue; \
  89         } \
  90 }
  91
  92 #define TELEM_CHECK_AND_PARSE_CTRS(EVTID, CTR) { \
  93         if (evtlog[index].telem_evtid == (EVTID)) { \
  94                 (CTR) = evtlog[index].telem_evtlog; \
  95                 continue; \
  96         } \
  97 }
  98
  99 static u8 suspend_prep_ok;
 100 static u32 suspend_shlw_ctr_temp, suspend_deep_ctr_temp;
 101 static u64 suspend_shlw_res_temp, suspend_deep_res_temp;
 102
 103 struct telemetry_susp_stats {
 104         u32 shlw_swake_ctr;
 105         u32 deep_swake_ctr;
 106         u64 shlw_swake_res;
 107         u64 deep_swake_res;
 108         u32 shlw_ctr;
 109         u32 deep_ctr;
 110         u64 shlw_res;
 111         u64 deep_res;
 112 };
 113
 114 /* Bitmap definitions for default counters in APL */
 115 struct telem_pss_idle_stateinfo {
 116         const char *name;
 117         u32 bit_pos;
 118 };
 119
 120 static struct telem_pss_idle_stateinfo telem_apl_pss_idle_data[] = {
 121         {"IA_CORE0_C1E",                0},
 122         {"IA_CORE1_C1E",                1},
 123         {"IA_CORE2_C1E",                2},
 124         {"IA_CORE3_C1E",                3},
 125         {"IA_CORE0_C6",                 16},
 126         {"IA_CORE1_C6",                 17},
 127         {"IA_CORE2_C6",                 18},
 128         {"IA_CORE3_C6",                 19},
 129         {"IA_MODULE0_C7",               32},
 130         {"IA_MODULE1_C7",               33},
 131         {"GT_RC6",                      40},
 132         {"IUNIT_PROCESSING_IDLE",       41},
 133         {"FAR_MEM_IDLE",                43},
 134         {"DISPLAY_IDLE",                44},
 135         {"IUNIT_INPUT_SYSTEM_IDLE",     45},
 136         {"PCS_STATUS",                  60},
 137 };
 138
 139 struct telem_pcs_blkd_info {
 140         const char *name;
 141         u32 bit_pos;
 142 };
 143
 144 static struct telem_pcs_blkd_info telem_apl_pcs_idle_blkd_data[] = {
 145         {"COMPUTE",                     0},
 146         {"MISC",                        8},
 147         {"MODULE_ACTIONS_PENDING",      16},
 148         {"LTR",                         24},
 149         {"DISPLAY_WAKE",                32},
 150         {"ISP_WAKE",                    40},
 151         {"PSF0_ACTIVE",                 48},
 152 };
 153
 154 static struct telem_pcs_blkd_info telem_apl_pcs_s0ix_blkd_data[] = {
 155         {"LTR",                         0},
 156         {"IRTL",                        8},
 157         {"WAKE_DEADLINE_PENDING",       16},
 158         {"DISPLAY",                     24},
 159         {"ISP",                         32},
 160         {"CORE",                        40},
 161         {"PMC",                         48},
 162         {"MISC",                        56},
 163 };
 164
 165 struct telem_pss_ltr_info {
 166         const char *name;
 167         u32 bit_pos;
 168 };
 169
 170 static struct telem_pss_ltr_info telem_apl_pss_ltr_data[] = {
 171         {"CORE_ACTIVE",         0},
 172         {"MEM_UP",              8},
 173         {"DFX",                 16},
 174         {"DFX_FORCE_LTR",       24},
 175         {"DISPLAY",             32},
 176         {"ISP",                 40},
 177         {"SOUTH",               48},
 178 };
 179
 180 struct telem_pss_wakeup_info {
 181         const char *name;
 182         u32 bit_pos;
 183 };
 184
 185 static struct telem_pss_wakeup_info telem_apl_pss_wakeup[] = {
 186         {"IP_IDLE",                     0},
 187         {"DISPLAY_WAKE",                8},
 188         {"VOLTAGE_REG_INT",             16},
 189         {"DROWSY_TIMER (HOTPLUG)",      24},
 190         {"CORE_WAKE",                   32},
 191         {"MISC_S0IX",                   40},
 192         {"MISC_ABORT",                  56},
 193 };
 194
 195 struct telem_ioss_d0ix_stateinfo {
 196         const char *name;
 197         u32 bit_pos;
 198 };
 199
 200 static struct telem_ioss_d0ix_stateinfo telem_apl_ioss_d0ix_data[] = {
 201         {"CSE",         0},
 202         {"SCC2",        1},
 203         {"GMM",         2},
 204         {"XDCI",        3},
 205         {"XHCI",        4},
 206         {"ISH",         5},
 207         {"AVS",         6},
 208         {"PCIE0P1",     7},
 209         {"PECI0P0",     8},
 210         {"LPSS",        9},
 211         {"SCC",         10},
 212         {"PWM",         11},
 213         {"PCIE1_P3",    12},
 214         {"PCIE1_P2",    13},
 215         {"PCIE1_P1",    14},
 216         {"PCIE1_P0",    15},
 217         {"CNV",         16},
 218         {"SATA",        17},
 219         {"PRTC",        18},
 220 };
 221
 222 struct telem_ioss_pg_info {
 223         const char *name;
 224         u32 bit_pos;
 225 };
 226
 227 static struct telem_ioss_pg_info telem_apl_ioss_pg_data[] = {
 228         {"LPSS",        0},
 229         {"SCC",         1},
 230         {"P2SB",        2},
 231         {"SCC2",        3},
 232         {"GMM",         4},
 233         {"PCIE0",       5},
 234         {"XDCI",        6},
 235         {"xHCI",        7},
 236         {"CSE",         8},
 237         {"SPI",         9},
 238         {"AVSPGD4",     10},
 239         {"AVSPGD3",     11},
 240         {"AVSPGD2",     12},
 241         {"AVSPGD1",     13},
 242         {"ISH",         14},
 243         {"EXI",         15},
 244         {"NPKVRC",      16},
 245         {"NPKVNN",      17},
 246         {"CUNIT",       18},
 247         {"FUSE_CTRL",   19},
 248         {"PCIE1",       20},
 249         {"CNV",         21},
 250         {"LPC",         22},
 251         {"SATA",        23},
 252         {"SMB",         24},
 253         {"PRTC",        25},
 254 };
 255
 256
 257 struct telemetry_debugfs_conf {
 258         struct telemetry_susp_stats suspend_stats;
 259         struct dentry *telemetry_dbg_dir;
 260
 261         /* Bitmap Data */
 262         struct telem_ioss_d0ix_stateinfo *ioss_d0ix_data;
 263         struct telem_pss_idle_stateinfo *pss_idle_data;
 264         struct telem_pcs_blkd_info *pcs_idle_blkd_data;
 265         struct telem_pcs_blkd_info *pcs_s0ix_blkd_data;
 266         struct telem_pss_wakeup_info *pss_wakeup;
 267         struct telem_pss_ltr_info *pss_ltr_data;
 268         struct telem_ioss_pg_info *ioss_pg_data;
 269         u8 pcs_idle_blkd_evts;
 270         u8 pcs_s0ix_blkd_evts;
 271         u8 pss_wakeup_evts;
 272         u8 pss_idle_evts;
 273         u8 pss_ltr_evts;
 274         u8 ioss_d0ix_evts;
 275         u8 ioss_pg_evts;
 276
 277         /* IDs */
 278         u16  pss_ltr_blocking_id;
 279         u16  pcs_idle_blkd_id;
 280         u16  pcs_s0ix_blkd_id;
 281         u16  s0ix_total_occ_id;
 282         u16  s0ix_shlw_occ_id;
 283         u16  s0ix_deep_occ_id;
 284         u16  s0ix_total_res_id;
 285         u16  s0ix_shlw_res_id;
 286         u16  s0ix_deep_res_id;
 287         u16  pss_wakeup_id;
 288         u16  ioss_d0ix_id;
 289         u16  pstates_id;
 290         u16  pss_idle_id;
 291         u16  ioss_d3_id;
 292         u16  ioss_pg_id;
 293 };
 294
 295 static struct telemetry_debugfs_conf *debugfs_conf;
 296
 297 static struct telemetry_debugfs_conf telem_apl_debugfs_conf = {
 298         .pss_idle_data = telem_apl_pss_idle_data,
 299         .pcs_idle_blkd_data = telem_apl_pcs_idle_blkd_data,
 300         .pcs_s0ix_blkd_data = telem_apl_pcs_s0ix_blkd_data,
 301         .pss_ltr_data = telem_apl_pss_ltr_data,
 302         .pss_wakeup = telem_apl_pss_wakeup,
 303         .ioss_d0ix_data = telem_apl_ioss_d0ix_data,
 304         .ioss_pg_data = telem_apl_ioss_pg_data,
 305
 306         .pss_idle_evts = TELEM_EVT_LEN(telem_apl_pss_idle_data),
 307         .pcs_idle_blkd_evts = TELEM_EVT_LEN(telem_apl_pcs_idle_blkd_data),
 308         .pcs_s0ix_blkd_evts = TELEM_EVT_LEN(telem_apl_pcs_s0ix_blkd_data),
 309         .pss_ltr_evts = TELEM_EVT_LEN(telem_apl_pss_ltr_data),
 310         .pss_wakeup_evts = TELEM_EVT_LEN(telem_apl_pss_wakeup),
 311         .ioss_d0ix_evts = TELEM_EVT_LEN(telem_apl_ioss_d0ix_data),
 312         .ioss_pg_evts = TELEM_EVT_LEN(telem_apl_ioss_pg_data),
 313
 314         .pstates_id = TELEM_APL_PSS_PSTATES_ID,
 315         .pss_idle_id = TELEM_APL_PSS_IDLE_ID,
 316         .pcs_idle_blkd_id = TELEM_APL_PCS_IDLE_BLOCKED_ID,
 317         .pcs_s0ix_blkd_id = TELEM_APL_PCS_S0IX_BLOCKED_ID,
 318         .pss_wakeup_id = TELEM_APL_PSS_WAKEUP_ID,
 319         .pss_ltr_blocking_id = TELEM_APL_PSS_LTR_BLOCKING_ID,
 320         .s0ix_total_occ_id = TELEM_APL_S0IX_TOTAL_OCC_ID,
 321         .s0ix_shlw_occ_id = TELEM_APL_S0IX_SHLW_OCC_ID,
 322         .s0ix_deep_occ_id = TELEM_APL_S0IX_DEEP_OCC_ID,
 323         .s0ix_total_res_id = TELEM_APL_S0IX_TOTAL_RES_ID,
 324         .s0ix_shlw_res_id = TELEM_APL_S0IX_SHLW_RES_ID,
 325         .s0ix_deep_res_id = TELEM_APL_S0IX_DEEP_RES_ID,
 326         .ioss_d0ix_id = TELEM_APL_D0IX_ID,
 327         .ioss_d3_id = TELEM_APL_D3_ID,
 328         .ioss_pg_id = TELEM_APL_PG_ID,
 329 };
 330
 331 static const struct x86_cpu_id telemetry_debugfs_cpu_ids[] = {
 332         TELEM_DEBUGFS_CPU(0x5c, telem_apl_debugfs_conf),
 333         {}
 334 };
 335
 336 MODULE_DEVICE_TABLE(x86cpu, telemetry_debugfs_cpu_ids);
 337
 338 static int telemetry_debugfs_check_evts(void)
 339 {
 340         if ((debugfs_conf->pss_idle_evts > TELEM_PSS_IDLE_EVTS) ||
 341             (debugfs_conf->pcs_idle_blkd_evts > TELEM_PSS_IDLE_BLOCKED_EVTS) ||
 342             (debugfs_conf->pcs_s0ix_blkd_evts > TELEM_PSS_S0IX_BLOCKED_EVTS) ||
 343             (debugfs_conf->pss_ltr_evts > TELEM_PSS_LTR_BLOCKING_EVTS) ||
 344             (debugfs_conf->pss_wakeup_evts > TELEM_PSS_S0IX_WAKEUP_EVTS) ||
 345             (debugfs_conf->ioss_d0ix_evts > TELEM_IOSS_DX_D0IX_EVTS) ||
 346             (debugfs_conf->ioss_pg_evts > TELEM_IOSS_PG_EVTS))
 347                 return -EINVAL;
 348
 349         return 0;
 350 }
 351
 352 static int telem_pss_states_show(struct seq_file *s, void *unused)
 353 {
 354         struct telemetry_evtlog evtlog[TELEM_MAX_OS_ALLOCATED_EVENTS];
 355         struct telemetry_debugfs_conf *conf = debugfs_conf;
 356         const char *name[TELEM_MAX_OS_ALLOCATED_EVENTS];
 357         u32 pcs_idle_blkd[TELEM_PSS_IDLE_BLOCKED_EVTS],
 358             pcs_s0ix_blkd[TELEM_PSS_S0IX_BLOCKED_EVTS],
 359             pss_s0ix_wakeup[TELEM_PSS_S0IX_WAKEUP_EVTS],
 360             pss_ltr_blkd[TELEM_PSS_LTR_BLOCKING_EVTS],
 361             pss_idle[TELEM_PSS_IDLE_EVTS];
 362         int index, idx, ret, err = 0;
 363         u64 pstates = 0;
 364
 365         ret = telemetry_read_eventlog(TELEM_PSS, evtlog,
 366                                       TELEM_MAX_OS_ALLOCATED_EVENTS);
 367         if (ret < 0)
 368                 return ret;
 369
 370         err = telemetry_get_evtname(TELEM_PSS, name,
 371                                     TELEM_MAX_OS_ALLOCATED_EVENTS);
 372         if (err < 0)
 373                 return err;
 374
 375         seq_puts(s, "\n----------------------------------------------------\n");
 376         seq_puts(s, "\tPSS TELEM EVENTLOG (Residency = field/19.2 us\n");
 377         seq_puts(s, "----------------------------------------------------\n");
 378         for (index = 0; index < ret; index++) {
 379                 seq_printf(s, "%-32s %llu\n",
 380                            name[index], evtlog[index].telem_evtlog);
 381
 382                 /* Fetch PSS IDLE State */
 383                 if (evtlog[index].telem_evtid == conf->pss_idle_id) {
 384                         pss_idle[conf->pss_idle_evts - 1] =
 385                         (evtlog[index].telem_evtlog >>
 386                         conf->pss_idle_data[conf->pss_idle_evts - 1].bit_pos) &
 387                         TELEM_APL_MASK_PCS_STATE;
 388                 }
 389
 390
 391                 TELEM_CHECK_AND_PARSE_EVTS(conf->pss_idle_id,
 392                                            conf->pss_idle_evts - 1,
 393                                            pss_idle, evtlog[index].telem_evtlog,
 394                                            conf->pss_idle_data, TELEM_MASK_BIT);
 395
 396                 TELEM_CHECK_AND_PARSE_EVTS(conf->pcs_idle_blkd_id,
 397                                            conf->pcs_idle_blkd_evts,
 398                                            pcs_idle_blkd,
 399                                            evtlog[index].telem_evtlog,
 400                                            conf->pcs_idle_blkd_data,
 401                                            TELEM_MASK_BYTE);
 402
 403                 TELEM_CHECK_AND_PARSE_EVTS(conf->pcs_s0ix_blkd_id,
 404                                            conf->pcs_s0ix_blkd_evts,
 405                                            pcs_s0ix_blkd,
 406                                            evtlog[index].telem_evtlog,
 407                                            conf->pcs_s0ix_blkd_data,
 408                                            TELEM_MASK_BYTE);
 409
 410
 411                 TELEM_CHECK_AND_PARSE_EVTS(conf->pss_wakeup_id,
 412                                            conf->pss_wakeup_evts,
 413                                            pss_s0ix_wakeup,
 414                                            evtlog[index].telem_evtlog,
 415                                            conf->pss_wakeup, TELEM_MASK_BYTE);
 416
 417                 TELEM_CHECK_AND_PARSE_EVTS(conf->pss_ltr_blocking_id,
 418                                            conf->pss_ltr_evts, pss_ltr_blkd,
 419                                            evtlog[index].telem_evtlog,
 420                                            conf->pss_ltr_data, TELEM_MASK_BYTE);
 421
 422                 if (evtlog[index].telem_evtid == debugfs_conf->pstates_id)
 423                         pstates = evtlog[index].telem_evtlog;
 424         }
 425
 426         seq_puts(s, "\n--------------------------------------\n");
 427         seq_puts(s, "PStates\n");
 428         seq_puts(s, "--------------------------------------\n");
 429         seq_puts(s, "Domain\t\t\t\tFreq(Mhz)\n");
 430         seq_printf(s, " IA\t\t\t\t %llu\n GT\t\t\t\t %llu\n",
 431                    (pstates & TELEM_MASK_BYTE)*100,
 432                    ((pstates >> 8) & TELEM_MASK_BYTE)*50/3);
 433
 434         seq_printf(s, " IUNIT\t\t\t\t %llu\n SA\t\t\t\t %llu\n",
 435                    ((pstates >> 16) & TELEM_MASK_BYTE)*25,
 436                    ((pstates >> 24) & TELEM_MASK_BYTE)*50/3);
 437
 438         seq_puts(s, "\n--------------------------------------\n");
 439         seq_puts(s, "PSS IDLE Status\n");
 440         seq_puts(s, "--------------------------------------\n");
 441         seq_puts(s, "Device\t\t\t\t\tIDLE\n");
 442         for (index = 0; index < debugfs_conf->pss_idle_evts; index++) {
 443                 seq_printf(s, "%-32s\t%u\n",
 444                            debugfs_conf->pss_idle_data[index].name,
 445                            pss_idle[index]);
 446         }
 447
 448         seq_puts(s, "\n--------------------------------------\n");
 449         seq_puts(s, "PSS Idle blkd Status (~1ms saturating bucket)\n");
 450         seq_puts(s, "--------------------------------------\n");
 451         seq_puts(s, "Blocker\t\t\t\t\tCount\n");
 452         for (index = 0; index < debugfs_conf->pcs_idle_blkd_evts; index++) {
 453                 seq_printf(s, "%-32s\t%u\n",
 454                            debugfs_conf->pcs_idle_blkd_data[index].name,
 455                            pcs_idle_blkd[index]);
 456         }
 457
 458         seq_puts(s, "\n--------------------------------------\n");
 459         seq_puts(s, "PSS S0ix blkd Status (~1ms saturating bucket)\n");
 460         seq_puts(s, "--------------------------------------\n");
 461         seq_puts(s, "Blocker\t\t\t\t\tCount\n");
 462         for (index = 0; index < debugfs_conf->pcs_s0ix_blkd_evts; index++) {
 463                 seq_printf(s, "%-32s\t%u\n",
 464                            debugfs_conf->pcs_s0ix_blkd_data[index].name,
 465                            pcs_s0ix_blkd[index]);
 466         }
 467
 468         seq_puts(s, "\n--------------------------------------\n");
 469         seq_puts(s, "LTR Blocking Status (~1ms saturating bucket)\n");
 470         seq_puts(s, "--------------------------------------\n");
 471         seq_puts(s, "Blocker\t\t\t\t\tCount\n");
 472         for (index = 0; index < debugfs_conf->pss_ltr_evts; index++) {
 473                 seq_printf(s, "%-32s\t%u\n",
 474                            debugfs_conf->pss_ltr_data[index].name,
 475                            pss_s0ix_wakeup[index]);
 476         }
 477
 478         seq_puts(s, "\n--------------------------------------\n");
 479         seq_puts(s, "Wakes Status (~1ms saturating bucket)\n");
 480         seq_puts(s, "--------------------------------------\n");
 481         seq_puts(s, "Wakes\t\t\t\t\tCount\n");
 482         for (index = 0; index < debugfs_conf->pss_wakeup_evts; index++) {
 483                 seq_printf(s, "%-32s\t%u\n",
 484                            debugfs_conf->pss_wakeup[index].name,
 485                            pss_ltr_blkd[index]);
 486         }
 487
 488         return 0;
 489 }
 490
 491 static int telem_pss_state_open(struct inode *inode, struct file *file)
 492 {
 493         return single_open(file, telem_pss_states_show, inode->i_private);
 494 }
 495
 496 static const struct file_operations telem_pss_ops = {
 497         .open           = telem_pss_state_open,
 498         .read           = seq_read,
 499         .llseek         = seq_lseek,
 500         .release        = single_release,
 501 };
 502
 503
 504 static int telem_ioss_states_show(struct seq_file *s, void *unused)
 505 {
 506         struct telemetry_evtlog evtlog[TELEM_MAX_OS_ALLOCATED_EVENTS];
 507         const char *name[TELEM_MAX_OS_ALLOCATED_EVENTS];
 508         int index, ret, err;
 509
 510         ret = telemetry_read_eventlog(TELEM_IOSS, evtlog,
 511                                       TELEM_MAX_OS_ALLOCATED_EVENTS);
 512         if (ret < 0)
 513                 return ret;
 514
 515         err = telemetry_get_evtname(TELEM_IOSS, name,
 516                                     TELEM_MAX_OS_ALLOCATED_EVENTS);
 517         if (err < 0)
 518                 return err;
 519
 520         seq_puts(s, "--------------------------------------\n");
 521         seq_puts(s, "\tI0SS TELEMETRY EVENTLOG\n");
 522         seq_puts(s, "--------------------------------------\n");
 523         for (index = 0; index < ret; index++) {
 524                 seq_printf(s, "%-32s 0x%llx\n",
 525                            name[index], evtlog[index].telem_evtlog);
 526         }
 527
 528         return 0;
 529 }
 530
 531 static int telem_ioss_state_open(struct inode *inode, struct file *file)
 532 {
 533         return single_open(file, telem_ioss_states_show, inode->i_private);
 534 }
 535
 536 static const struct file_operations telem_ioss_ops = {
 537         .open           = telem_ioss_state_open,
 538         .read           = seq_read,
 539         .llseek         = seq_lseek,
 540         .release        = single_release,
 541 };
 542
 543 static int telem_soc_states_show(struct seq_file *s, void *unused)
 544 {
 545         u32 d3_sts[TELEM_IOSS_DX_D0IX_EVTS], d0ix_sts[TELEM_IOSS_DX_D0IX_EVTS];
 546         u32 pg_sts[TELEM_IOSS_PG_EVTS], pss_idle[TELEM_PSS_IDLE_EVTS];
 547         struct telemetry_evtlog evtlog[TELEM_MAX_OS_ALLOCATED_EVENTS];
 548         u32 s0ix_total_ctr = 0, s0ix_shlw_ctr = 0, s0ix_deep_ctr = 0;
 549         u64 s0ix_total_res = 0, s0ix_shlw_res = 0, s0ix_deep_res = 0;
 550         struct telemetry_debugfs_conf *conf = debugfs_conf;
 551         struct pci_dev *dev = NULL;
 552         int index, idx, ret;
 553         u32 d3_state;
 554         u16 pmcsr;
 555
 556         ret = telemetry_read_eventlog(TELEM_IOSS, evtlog,
 557                                       TELEM_MAX_OS_ALLOCATED_EVENTS);
 558         if (ret < 0)
 559                 return ret;
 560
 561         for (index = 0; index < ret; index++) {
 562                 TELEM_CHECK_AND_PARSE_EVTS(conf->ioss_d3_id,
 563                                            conf->ioss_d0ix_evts,
 564                                            d3_sts, evtlog[index].telem_evtlog,
 565                                            conf->ioss_d0ix_data,
 566                                            TELEM_MASK_BIT);
 567
 568                 TELEM_CHECK_AND_PARSE_EVTS(conf->ioss_pg_id, conf->ioss_pg_evts,
 569                                            pg_sts, evtlog[index].telem_evtlog,
 570                                            conf->ioss_pg_data, TELEM_MASK_BIT);
 571
 572                 TELEM_CHECK_AND_PARSE_EVTS(conf->ioss_d0ix_id,
 573                                            conf->ioss_d0ix_evts,
 574                                            d0ix_sts, evtlog[index].telem_evtlog,
 575                                            conf->ioss_d0ix_data,
 576                                            TELEM_MASK_BIT);
 577
 578                 TELEM_CHECK_AND_PARSE_CTRS(conf->s0ix_total_occ_id,
 579                                            s0ix_total_ctr);
 580
 581                 TELEM_CHECK_AND_PARSE_CTRS(conf->s0ix_shlw_occ_id,
 582                                            s0ix_shlw_ctr);
 583
 584                 TELEM_CHECK_AND_PARSE_CTRS(conf->s0ix_deep_occ_id,
 585                                            s0ix_deep_ctr);
 586
 587                 TELEM_CHECK_AND_PARSE_CTRS(conf->s0ix_total_res_id,
 588                                            s0ix_total_res);
 589
 590                 TELEM_CHECK_AND_PARSE_CTRS(conf->s0ix_shlw_res_id,
 591                                            s0ix_shlw_res);
 592
 593                 TELEM_CHECK_AND_PARSE_CTRS(conf->s0ix_deep_res_id,
 594                                            s0ix_deep_res);
 595         }
 596
 597         seq_puts(s, "\n---------------------------------------------------\n");
 598         seq_puts(s, "S0IX Type\t\t\t Occurrence\t\t Residency(us)\n");
 599         seq_puts(s, "---------------------------------------------------\n");
 600
 601         seq_printf(s, "S0IX Shallow\t\t\t %10u\t %10llu\n",
 602                    s0ix_shlw_ctr -
 603                    conf->suspend_stats.shlw_ctr -
 604                    conf->suspend_stats.shlw_swake_ctr,
 605                    (u64)((s0ix_shlw_res -
 606                    conf->suspend_stats.shlw_res -
 607                    conf->suspend_stats.shlw_swake_res)*10/192));
 608
 609         seq_printf(s, "S0IX Deep\t\t\t %10u\t %10llu\n",
 610                    s0ix_deep_ctr -
 611                    conf->suspend_stats.deep_ctr -
 612                    conf->suspend_stats.deep_swake_ctr,
 613                    (u64)((s0ix_deep_res -
 614                    conf->suspend_stats.deep_res -
 615                    conf->suspend_stats.deep_swake_res)*10/192));
 616
 617         seq_printf(s, "Suspend(With S0ixShallow)\t %10u\t %10llu\n",
 618                    conf->suspend_stats.shlw_ctr,
 619                    (u64)(conf->suspend_stats.shlw_res*10)/192);
 620
 621         seq_printf(s, "Suspend(With S0ixDeep)\t\t %10u\t %10llu\n",
 622                    conf->suspend_stats.deep_ctr,
 623                    (u64)(conf->suspend_stats.deep_res*10)/192);
 624
 625         seq_printf(s, "Suspend(With Shallow-Wakes)\t %10u\t %10llu\n",
 626                    conf->suspend_stats.shlw_swake_ctr +
 627                    conf->suspend_stats.deep_swake_ctr,
 628                    (u64)((conf->suspend_stats.shlw_swake_res +
 629                    conf->suspend_stats.deep_swake_res)*10/192));
 630
 631         seq_printf(s, "S0IX+Suspend Total\t\t %10u\t %10llu\n", s0ix_total_ctr,
 632                                 (u64)(s0ix_total_res*10/192));
 633         seq_puts(s, "\n-------------------------------------------------\n");
 634         seq_puts(s, "\t\tDEVICE STATES\n");
 635         seq_puts(s, "-------------------------------------------------\n");
 636
 637         for_each_pci_dev(dev) {
 638                 pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);
 639                 d3_state = ((pmcsr & PCI_PM_CTRL_STATE_MASK) ==
 640                             (__force int)PCI_D3hot) ? 1 : 0;
 641
 642                 seq_printf(s, "pci %04x %04X %s %20.20s: ",
 643                            dev->vendor, dev->device, dev_name(&dev->dev),
 644                            dev_driver_string(&dev->dev));
 645                 seq_printf(s, " d3:%x\n", d3_state);
 646         }
 647
 648         seq_puts(s, "\n--------------------------------------\n");
 649         seq_puts(s, "D3/D0i3 Status\n");
 650         seq_puts(s, "--------------------------------------\n");
 651         seq_puts(s, "Block\t\t D3\t D0i3\n");
 652         for (index = 0; index < conf->ioss_d0ix_evts; index++) {
 653                 seq_printf(s, "%-10s\t %u\t %u\n",
 654                            conf->ioss_d0ix_data[index].name,
 655                            d3_sts[index], d0ix_sts[index]);
 656         }
 657
 658         seq_puts(s, "\n--------------------------------------\n");
 659         seq_puts(s, "South Complex PowerGate Status\n");
 660         seq_puts(s, "--------------------------------------\n");
 661         seq_puts(s, "Device\t\t PG\n");
 662         for (index = 0; index < conf->ioss_pg_evts; index++) {
 663                 seq_printf(s, "%-10s\t %u\n",
 664                            conf->ioss_pg_data[index].name,
 665                            pg_sts[index]);
 666         }
 667
 668         evtlog->telem_evtid = conf->pss_idle_id;
 669         ret = telemetry_read_events(TELEM_PSS, evtlog, 1);
 670         if (ret < 0)
 671                 return ret;
 672
 673         seq_puts(s, "\n-----------------------------------------\n");
 674         seq_puts(s, "North Idle Status\n");
 675         seq_puts(s, "-----------------------------------------\n");
 676         for (idx = 0; idx < conf->pss_idle_evts - 1; idx++) {
 677                 pss_idle[idx] = (evtlog->telem_evtlog >>
 678                                 conf->pss_idle_data[idx].bit_pos) &
 679                                 TELEM_MASK_BIT;
 680         }
 681
 682         pss_idle[idx] = (evtlog->telem_evtlog >>
 683                         conf->pss_idle_data[idx].bit_pos) &
 684                         TELEM_APL_MASK_PCS_STATE;
 685
 686         for (index = 0; index < conf->pss_idle_evts; index++) {
 687                 seq_printf(s, "%-30s %u\n",
 688                            conf->pss_idle_data[index].name,
 689                            pss_idle[index]);
 690         }
 691
 692         seq_puts(s, "\nPCS_STATUS Code\n");
 693         seq_puts(s, "0:C0 1:C1 2:C1_DN_WT_DEV 3:C2 4:C2_WT_DE_MEM_UP\n");
 694         seq_puts(s, "5:C2_WT_DE_MEM_DOWN 6:C2_UP_WT_DEV 7:C2_DN 8:C2_VOA\n");
 695         seq_puts(s, "9:C2_VOA_UP 10:S0IX_PRE 11:S0IX\n");
 696
 697         return 0;
 698 }
 699
 700 static int telem_soc_state_open(struct inode *inode, struct file *file)
 701 {
 702         return single_open(file, telem_soc_states_show, inode->i_private);
 703 }
 704
 705 static const struct file_operations telem_socstate_ops = {
 706         .open           = telem_soc_state_open,
 707         .read           = seq_read,
 708         .llseek         = seq_lseek,
 709         .release        = single_release,
 710 };
 711
 712 static int telem_pss_trc_verb_show(struct seq_file *s, void *unused)
 713 {
 714         u32 verbosity;
 715         int err;
 716
 717         err = telemetry_get_trace_verbosity(TELEM_PSS, &verbosity);
 718         if (err) {
 719                 pr_err("Get PSS Trace Verbosity Failed with Error %d\n", err);
 720                 return -EFAULT;
 721         }
 722
 723         seq_printf(s, "PSS Trace Verbosity %u\n", verbosity);
 724         return 0;
 725 }
 726
 727 static ssize_t telem_pss_trc_verb_write(struct file *file,
 728                                         const char __user *userbuf,
 729                                         size_t count, loff_t *ppos)
 730 {
 731         u32 verbosity;
 732         int err;
 733
 734         if (kstrtou32_from_user(userbuf, count, 0, &verbosity))
 735                 return -EFAULT;
 736
 737         err = telemetry_set_trace_verbosity(TELEM_PSS, verbosity);
 738         if (err) {
 739                 pr_err("Changing PSS Trace Verbosity Failed. Error %d\n", err);
 740                 count = err;
 741         }
 742
 743         return count;
 744 }
 745
 746 static int telem_pss_trc_verb_open(struct inode *inode, struct file *file)
 747 {
 748         return single_open(file, telem_pss_trc_verb_show, inode->i_private);
 749 }
 750
 751 static const struct file_operations telem_pss_trc_verb_ops = {
 752         .open           = telem_pss_trc_verb_open,
 753         .read           = seq_read,
 754         .write          = telem_pss_trc_verb_write,
 755         .llseek         = seq_lseek,
 756         .release        = single_release,
 757 };
 758
 759
 760 static int telem_ioss_trc_verb_show(struct seq_file *s, void *unused)
 761 {
 762         u32 verbosity;
 763         int err;
 764
 765         err = telemetry_get_trace_verbosity(TELEM_IOSS, &verbosity);
 766         if (err) {
 767                 pr_err("Get IOSS Trace Verbosity Failed with Error %d\n", err);
 768                 return -EFAULT;
 769         }
 770
 771         seq_printf(s, "IOSS Trace Verbosity %u\n", verbosity);
 772         return 0;
 773 }
 774
 775 static ssize_t telem_ioss_trc_verb_write(struct file *file,
 776                                          const char __user *userbuf,
 777                                          size_t count, loff_t *ppos)
 778 {
 779         u32 verbosity;
 780         int err;
 781
 782         if (kstrtou32_from_user(userbuf, count, 0, &verbosity))
 783                 return -EFAULT;
 784
 785         err = telemetry_set_trace_verbosity(TELEM_IOSS, verbosity);
 786         if (err) {
 787                 pr_err("Changing IOSS Trace Verbosity Failed. Error %d\n", err);
 788                 count = err;
 789         }
 790
 791         return count;
 792 }
 793
 794 static int telem_ioss_trc_verb_open(struct inode *inode, struct file *file)
 795 {
 796         return single_open(file, telem_ioss_trc_verb_show, inode->i_private);
 797 }
 798
 799 static const struct file_operations telem_ioss_trc_verb_ops = {
 800         .open           = telem_ioss_trc_verb_open,
 801         .read           = seq_read,
 802         .write          = telem_ioss_trc_verb_write,
 803         .llseek         = seq_lseek,
 804         .release        = single_release,
 805 };
 806
 807 #ifdef CONFIG_PM_SLEEP
 808 static int pm_suspend_prep_cb(void)
 809 {
 810         struct telemetry_evtlog evtlog[TELEM_MAX_OS_ALLOCATED_EVENTS];
 811         struct telemetry_debugfs_conf *conf = debugfs_conf;
 812         int ret, index;
 813
 814         ret = telemetry_raw_read_eventlog(TELEM_IOSS, evtlog,
 815                         TELEM_MAX_OS_ALLOCATED_EVENTS);
 816         if (ret < 0) {
 817                 suspend_prep_ok = 0;
 818                 goto out;
 819         }
 820
 821         for (index = 0; index < ret; index++) {
 822
 823                 TELEM_CHECK_AND_PARSE_CTRS(conf->s0ix_shlw_occ_id,
 824                                            suspend_shlw_ctr_temp);
 825
 826                 TELEM_CHECK_AND_PARSE_CTRS(conf->s0ix_deep_occ_id,
 827                                            suspend_deep_ctr_temp);
 828
 829                 TELEM_CHECK_AND_PARSE_CTRS(conf->s0ix_shlw_res_id,
 830                                            suspend_shlw_res_temp);
 831
 832                 TELEM_CHECK_AND_PARSE_CTRS(conf->s0ix_deep_res_id,
 833                                            suspend_deep_res_temp);
 834         }
 835         suspend_prep_ok = 1;
 836 out:
 837         return NOTIFY_OK;
 838 }
 839
 840 static int pm_suspend_exit_cb(void)
 841 {
 842         struct telemetry_evtlog evtlog[TELEM_MAX_OS_ALLOCATED_EVENTS];
 843         static u32 suspend_shlw_ctr_exit, suspend_deep_ctr_exit;
 844         static u64 suspend_shlw_res_exit, suspend_deep_res_exit;
 845         struct telemetry_debugfs_conf *conf = debugfs_conf;
 846         int ret, index;
 847
 848         if (!suspend_prep_ok)
 849                 goto out;
 850
 851         ret = telemetry_raw_read_eventlog(TELEM_IOSS, evtlog,
 852                                           TELEM_MAX_OS_ALLOCATED_EVENTS);
 853         if (ret < 0)
 854                 goto out;
 855
 856         for (index = 0; index < ret; index++) {
 857                 TELEM_CHECK_AND_PARSE_CTRS(conf->s0ix_shlw_occ_id,
 858                                            suspend_shlw_ctr_exit);
 859
 860                 TELEM_CHECK_AND_PARSE_CTRS(conf->s0ix_deep_occ_id,
 861                                            suspend_deep_ctr_exit);
 862
 863                 TELEM_CHECK_AND_PARSE_CTRS(conf->s0ix_shlw_res_id,
 864                                            suspend_shlw_res_exit);
 865
 866                 TELEM_CHECK_AND_PARSE_CTRS(conf->s0ix_deep_res_id,
 867                                            suspend_deep_res_exit);
 868         }
 869
 870         if ((suspend_shlw_ctr_exit < suspend_shlw_ctr_temp) ||
 871             (suspend_deep_ctr_exit < suspend_deep_ctr_temp) ||
 872             (suspend_shlw_res_exit < suspend_shlw_res_temp) ||
 873             (suspend_deep_res_exit < suspend_deep_res_temp)) {
 874                 pr_err("Wrong s0ix counters detected\n");
 875                 goto out;
 876         }
 877
 878         suspend_shlw_ctr_exit -= suspend_shlw_ctr_temp;
 879         suspend_deep_ctr_exit -= suspend_deep_ctr_temp;
 880         suspend_shlw_res_exit -= suspend_shlw_res_temp;
 881         suspend_deep_res_exit -= suspend_deep_res_temp;
 882
 883         if (suspend_shlw_ctr_exit == 1) {
 884                 conf->suspend_stats.shlw_ctr +=
 885                 suspend_shlw_ctr_exit;
 886
 887                 conf->suspend_stats.shlw_res +=
 888                 suspend_shlw_res_exit;
 889         }
 890         /* Shallow Wakes Case */
 891         else if (suspend_shlw_ctr_exit > 1) {
 892                 conf->suspend_stats.shlw_swake_ctr +=
 893                 suspend_shlw_ctr_exit;
 894
 895                 conf->suspend_stats.shlw_swake_res +=
 896                 suspend_shlw_res_exit;
 897         }
 898
 899         if (suspend_deep_ctr_exit == 1) {
 900                 conf->suspend_stats.deep_ctr +=
 901                 suspend_deep_ctr_exit;
 902
 903                 conf->suspend_stats.deep_res +=
 904                 suspend_deep_res_exit;
 905         }
 906
 907         /* Shallow Wakes Case */
 908         else if (suspend_deep_ctr_exit > 1) {
 909                 conf->suspend_stats.deep_swake_ctr +=
 910                 suspend_deep_ctr_exit;
 911
 912                 conf->suspend_stats.deep_swake_res +=
 913                 suspend_deep_res_exit;
 914         }
 915
 916 out:
 917         suspend_prep_ok = 0;
 918         return NOTIFY_OK;
 919 }
 920
 921 static int pm_notification(struct notifier_block *this,
 922                            unsigned long event, void *ptr)
 923 {
 924         switch (event) {
 925         case PM_SUSPEND_PREPARE:
 926                 return pm_suspend_prep_cb();
 927         case PM_POST_SUSPEND:
 928                 return pm_suspend_exit_cb();
 929         }
 930
 931         return NOTIFY_DONE;
 932 }
 933
 934 static struct notifier_block pm_notifier = {
 935         .notifier_call = pm_notification,
 936 };
 937 #endif /* CONFIG_PM_SLEEP */
 938
 939 static int __init telemetry_debugfs_init(void)
 940 {
 941         const struct x86_cpu_id *id;
 942         int err = -ENOMEM;
 943         struct dentry *f;
 944
 945         /* Only APL supported for now */
 946         id = x86_match_cpu(telemetry_debugfs_cpu_ids);
 947         if (!id)
 948                 return -ENODEV;
 949
 950         debugfs_conf = (struct telemetry_debugfs_conf *)id->driver_data;
 951
 952         err = telemetry_pltconfig_valid();
 953         if (err < 0)
 954                 return -ENODEV;
 955
 956         err = telemetry_debugfs_check_evts();
 957         if (err < 0)
 958                 return -EINVAL;
 959
 960
 961 #ifdef CONFIG_PM_SLEEP
 962         register_pm_notifier(&pm_notifier);
 963 #endif /* CONFIG_PM_SLEEP */
 964
 965         debugfs_conf->telemetry_dbg_dir = debugfs_create_dir("telemetry", NULL);
 966         if (!debugfs_conf->telemetry_dbg_dir)
 967                 return -ENOMEM;
 968
 969         f = debugfs_create_file("pss_info", S_IFREG | S_IRUGO,
 970                                 debugfs_conf->telemetry_dbg_dir, NULL,
 971                                 &telem_pss_ops);
 972         if (!f) {
 973                 pr_err("pss_sample_info debugfs register failed\n");
 974                 goto out;
 975         }
 976
 977         f = debugfs_create_file("ioss_info", S_IFREG | S_IRUGO,
 978                                 debugfs_conf->telemetry_dbg_dir, NULL,
 979                                 &telem_ioss_ops);
 980         if (!f) {
 981                 pr_err("ioss_sample_info debugfs register failed\n");
 982                 goto out;
 983         }
 984
 985         f = debugfs_create_file("soc_states", S_IFREG | S_IRUGO,
 986                                 debugfs_conf->telemetry_dbg_dir,
 987                                 NULL, &telem_socstate_ops);
 988         if (!f) {
 989                 pr_err("ioss_sample_info debugfs register failed\n");
 990                 goto out;
 991         }
 992
 993         f = debugfs_create_file("pss_trace_verbosity", S_IFREG | S_IRUGO,
 994                                 debugfs_conf->telemetry_dbg_dir, NULL,
 995                                 &telem_pss_trc_verb_ops);
 996         if (!f) {
 997                 pr_err("pss_trace_verbosity debugfs register failed\n");
 998                 goto out;
 999         }
1000
1001         f = debugfs_create_file("ioss_trace_verbosity", S_IFREG | S_IRUGO,
1002                                 debugfs_conf->telemetry_dbg_dir, NULL,
1003                                 &telem_ioss_trc_verb_ops);
1004         if (!f) {
1005                 pr_err("ioss_trace_verbosity debugfs register failed\n");
1006                 goto out;
1007         }
1008
1009         return 0;
1010
1011 out:
1012         debugfs_remove_recursive(debugfs_conf->telemetry_dbg_dir);
1013         debugfs_conf->telemetry_dbg_dir = NULL;
1014
1015         return err;
1016 }
1017
1018 static void __exit telemetry_debugfs_exit(void)
1019 {
1020         debugfs_remove_recursive(debugfs_conf->telemetry_dbg_dir);
1021         debugfs_conf->telemetry_dbg_dir = NULL;
1022 }
1023
1024 late_initcall(telemetry_debugfs_init);
1025 module_exit(telemetry_debugfs_exit);
1026
1027 MODULE_AUTHOR("Souvik Kumar Chakravarty <souvik.k.chakravarty@intel.com>");
1028 MODULE_DESCRIPTION("Intel SoC Telemetry debugfs Interface");
1029 MODULE_VERSION(DRIVER_VERSION);
1030 MODULE_LICENSE("GPL");