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