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