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_GEMINI_LAKE, telem_apl_debugfs_conf),
324 {}
325 };
326
327 MODULE_DEVICE_TABLE(x86cpu, telemetry_debugfs_cpu_ids);
328
telemetry_debugfs_check_evts(void)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
telem_pss_states_show(struct seq_file * s,void * unused)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
telem_pss_state_open(struct inode * inode,struct file * file)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
telem_ioss_states_show(struct seq_file * s,void * unused)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
telem_ioss_state_open(struct inode * inode,struct file * file)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
telem_soc_states_show(struct seq_file * s,void * unused)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
telem_soc_state_open(struct inode * inode,struct file * file)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
telem_s0ix_res_get(void * data,u64 * val)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
telem_pss_trc_verb_show(struct seq_file * s,void * unused)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
telem_pss_trc_verb_write(struct file * file,const char __user * userbuf,size_t count,loff_t * ppos)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
telem_pss_trc_verb_open(struct inode * inode,struct file * file)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
telem_ioss_trc_verb_show(struct seq_file * s,void * unused)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
telem_ioss_trc_verb_write(struct file * file,const char __user * userbuf,size_t count,loff_t * ppos)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
telem_ioss_trc_verb_open(struct inode * inode,struct file * file)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
pm_suspend_prep_cb(void)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
pm_suspend_exit_cb(void)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
pm_notification(struct notifier_block * this,unsigned long event,void * ptr)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
telemetry_debugfs_init(void)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
telemetry_debugfs_exit(void)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");
1041
