Commit | Line | Data |
---|---|---|
9d16b482 SKC |
1 | /* |
2 | * Intel SOC Telemetry Platform 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 platform specific telemetry implementation for APL. | |
16 | * It used the PUNIT and PMC IPC interfaces for configuring the counters. | |
17 | * The accumulated results are fetched from SRAM. | |
18 | */ | |
19 | #include <linux/module.h> | |
20 | #include <linux/init.h> | |
21 | #include <linux/device.h> | |
22 | #include <linux/debugfs.h> | |
23 | #include <linux/seq_file.h> | |
24 | #include <linux/io.h> | |
25 | #include <linux/uaccess.h> | |
26 | #include <linux/pci.h> | |
27 | #include <linux/suspend.h> | |
28 | #include <linux/platform_device.h> | |
29 | ||
30 | #include <asm/cpu_device_id.h> | |
31 | #include <asm/intel_pmc_ipc.h> | |
32 | #include <asm/intel_punit_ipc.h> | |
33 | #include <asm/intel_telemetry.h> | |
34 | ||
35 | #define DRIVER_NAME "intel_telemetry" | |
36 | #define DRIVER_VERSION "1.0.0" | |
37 | ||
38 | #define TELEM_TRC_VERBOSITY_MASK 0x3 | |
39 | ||
40 | #define TELEM_MIN_PERIOD(x) ((x) & 0x7F0000) | |
41 | #define TELEM_MAX_PERIOD(x) ((x) & 0x7F000000) | |
42 | #define TELEM_SAMPLE_PERIOD_INVALID(x) ((x) & (BIT(7))) | |
43 | #define TELEM_CLEAR_SAMPLE_PERIOD(x) ((x) &= ~0x7F) | |
44 | ||
45 | #define TELEM_SAMPLING_DEFAULT_PERIOD 0xD | |
46 | ||
47 | #define TELEM_MAX_EVENTS_SRAM 28 | |
48 | #define TELEM_MAX_OS_ALLOCATED_EVENTS 20 | |
49 | #define TELEM_SSRAM_STARTTIME_OFFSET 8 | |
50 | #define TELEM_SSRAM_EVTLOG_OFFSET 16 | |
51 | ||
52 | #define IOSS_TELEM_EVENT_READ 0x0 | |
53 | #define IOSS_TELEM_EVENT_WRITE 0x1 | |
54 | #define IOSS_TELEM_INFO_READ 0x2 | |
55 | #define IOSS_TELEM_TRACE_CTL_READ 0x5 | |
56 | #define IOSS_TELEM_TRACE_CTL_WRITE 0x6 | |
57 | #define IOSS_TELEM_EVENT_CTL_READ 0x7 | |
58 | #define IOSS_TELEM_EVENT_CTL_WRITE 0x8 | |
59 | #define IOSS_TELEM_EVT_CTRL_WRITE_SIZE 0x4 | |
60 | #define IOSS_TELEM_READ_WORD 0x1 | |
61 | #define IOSS_TELEM_WRITE_FOURBYTES 0x4 | |
62 | #define IOSS_TELEM_EVT_WRITE_SIZE 0x3 | |
63 | ||
64 | #define TELEM_INFO_SRAMEVTS_MASK 0xFF00 | |
65 | #define TELEM_INFO_SRAMEVTS_SHIFT 0x8 | |
66 | #define TELEM_SSRAM_READ_TIMEOUT 10 | |
67 | ||
68 | #define TELEM_INFO_NENABLES_MASK 0xFF | |
69 | #define TELEM_EVENT_ENABLE 0x8000 | |
70 | ||
71 | #define TELEM_MASK_BIT 1 | |
72 | #define TELEM_MASK_BYTE 0xFF | |
73 | #define BYTES_PER_LONG 8 | |
74 | #define TELEM_MASK_PCS_STATE 0xF | |
75 | ||
76 | #define TELEM_DISABLE(x) ((x) &= ~(BIT(31))) | |
77 | #define TELEM_CLEAR_EVENTS(x) ((x) |= (BIT(30))) | |
78 | #define TELEM_ENABLE_SRAM_EVT_TRACE(x) ((x) &= ~(BIT(30) | BIT(24))) | |
79 | #define TELEM_ENABLE_PERIODIC(x) ((x) |= (BIT(23) | BIT(31) | BIT(7))) | |
80 | #define TELEM_EXTRACT_VERBOSITY(x, y) ((y) = (((x) >> 27) & 0x3)) | |
81 | #define TELEM_CLEAR_VERBOSITY_BITS(x) ((x) &= ~(BIT(27) | BIT(28))) | |
82 | #define TELEM_SET_VERBOSITY_BITS(x, y) ((x) |= ((y) << 27)) | |
83 | ||
84 | #define TELEM_CPU(model, data) \ | |
85 | { X86_VENDOR_INTEL, 6, model, X86_FEATURE_MWAIT, (unsigned long)&data } | |
86 | ||
87 | enum telemetry_action { | |
88 | TELEM_UPDATE = 0, | |
89 | TELEM_ADD, | |
90 | TELEM_RESET, | |
91 | TELEM_ACTION_NONE | |
92 | }; | |
93 | ||
94 | struct telem_ssram_region { | |
95 | u64 timestamp; | |
96 | u64 start_time; | |
97 | u64 events[TELEM_MAX_EVENTS_SRAM]; | |
98 | }; | |
99 | ||
100 | static struct telemetry_plt_config *telm_conf; | |
101 | ||
102 | /* | |
103 | * The following counters are programmed by default during setup. | |
104 | * Only 20 allocated to kernel driver | |
105 | */ | |
106 | static struct telemetry_evtmap | |
107 | telemetry_apl_ioss_default_events[TELEM_MAX_OS_ALLOCATED_EVENTS] = { | |
108 | {"SOC_S0IX_TOTAL_RES", 0x4800}, | |
109 | {"SOC_S0IX_TOTAL_OCC", 0x4000}, | |
110 | {"SOC_S0IX_SHALLOW_RES", 0x4801}, | |
111 | {"SOC_S0IX_SHALLOW_OCC", 0x4001}, | |
112 | {"SOC_S0IX_DEEP_RES", 0x4802}, | |
113 | {"SOC_S0IX_DEEP_OCC", 0x4002}, | |
114 | {"PMC_POWER_GATE", 0x5818}, | |
115 | {"PMC_D3_STATES", 0x5819}, | |
116 | {"PMC_D0I3_STATES", 0x581A}, | |
117 | {"PMC_S0IX_WAKE_REASON_GPIO", 0x6000}, | |
118 | {"PMC_S0IX_WAKE_REASON_TIMER", 0x6001}, | |
119 | {"PMC_S0IX_WAKE_REASON_VNNREQ", 0x6002}, | |
120 | {"PMC_S0IX_WAKE_REASON_LOWPOWER", 0x6003}, | |
121 | {"PMC_S0IX_WAKE_REASON_EXTERNAL", 0x6004}, | |
122 | {"PMC_S0IX_WAKE_REASON_MISC", 0x6005}, | |
123 | {"PMC_S0IX_BLOCKING_IPS_D3_D0I3", 0x6006}, | |
124 | {"PMC_S0IX_BLOCKING_IPS_PG", 0x6007}, | |
125 | {"PMC_S0IX_BLOCKING_MISC_IPS_PG", 0x6008}, | |
126 | {"PMC_S0IX_BLOCK_IPS_VNN_REQ", 0x6009}, | |
127 | {"PMC_S0IX_BLOCK_IPS_CLOCKS", 0x600B}, | |
128 | }; | |
129 | ||
130 | ||
131 | static struct telemetry_evtmap | |
132 | telemetry_apl_pss_default_events[TELEM_MAX_OS_ALLOCATED_EVENTS] = { | |
133 | {"IA_CORE0_C6_RES", 0x0400}, | |
134 | {"IA_CORE0_C6_CTR", 0x0000}, | |
135 | {"IA_MODULE0_C7_RES", 0x0410}, | |
136 | {"IA_MODULE0_C7_CTR", 0x000E}, | |
137 | {"IA_C0_RES", 0x0805}, | |
138 | {"PCS_LTR", 0x2801}, | |
139 | {"PSTATES", 0x2802}, | |
140 | {"SOC_S0I3_RES", 0x0409}, | |
141 | {"SOC_S0I3_CTR", 0x000A}, | |
142 | {"PCS_S0I3_CTR", 0x0009}, | |
143 | {"PCS_C1E_RES", 0x041A}, | |
144 | {"PCS_IDLE_STATUS", 0x2806}, | |
145 | {"IA_PERF_LIMITS", 0x280B}, | |
146 | {"GT_PERF_LIMITS", 0x280C}, | |
147 | {"PCS_WAKEUP_S0IX_CTR", 0x0030}, | |
148 | {"PCS_IDLE_BLOCKED", 0x2C00}, | |
149 | {"PCS_S0IX_BLOCKED", 0x2C01}, | |
150 | {"PCS_S0IX_WAKE_REASONS", 0x2C02}, | |
151 | {"PCS_LTR_BLOCKING", 0x2C03}, | |
152 | {"PC2_AND_MEM_SHALLOW_IDLE_RES", 0x1D40}, | |
153 | }; | |
154 | ||
155 | /* APL specific Data */ | |
156 | static struct telemetry_plt_config telem_apl_config = { | |
157 | .pss_config = { | |
158 | .telem_evts = telemetry_apl_pss_default_events, | |
159 | }, | |
160 | .ioss_config = { | |
161 | .telem_evts = telemetry_apl_ioss_default_events, | |
162 | }, | |
163 | }; | |
164 | ||
165 | static const struct x86_cpu_id telemetry_cpu_ids[] = { | |
166 | TELEM_CPU(0x5c, telem_apl_config), | |
167 | {} | |
168 | }; | |
169 | ||
170 | MODULE_DEVICE_TABLE(x86cpu, telemetry_cpu_ids); | |
171 | ||
172 | static inline int telem_get_unitconfig(enum telemetry_unit telem_unit, | |
173 | struct telemetry_unit_config **unit_config) | |
174 | { | |
175 | if (telem_unit == TELEM_PSS) | |
176 | *unit_config = &(telm_conf->pss_config); | |
177 | else if (telem_unit == TELEM_IOSS) | |
178 | *unit_config = &(telm_conf->ioss_config); | |
179 | else | |
180 | return -EINVAL; | |
181 | ||
182 | return 0; | |
183 | ||
184 | } | |
185 | ||
186 | static int telemetry_check_evtid(enum telemetry_unit telem_unit, | |
187 | u32 *evtmap, u8 len, | |
188 | enum telemetry_action action) | |
189 | { | |
190 | struct telemetry_unit_config *unit_config; | |
191 | int ret; | |
192 | ||
193 | ret = telem_get_unitconfig(telem_unit, &unit_config); | |
194 | if (ret < 0) | |
195 | return ret; | |
196 | ||
197 | switch (action) { | |
198 | case TELEM_RESET: | |
199 | if (len > TELEM_MAX_EVENTS_SRAM) | |
200 | return -EINVAL; | |
201 | ||
202 | break; | |
203 | ||
204 | case TELEM_UPDATE: | |
205 | if (len > TELEM_MAX_EVENTS_SRAM) | |
206 | return -EINVAL; | |
207 | ||
208 | if ((len > 0) && (evtmap == NULL)) | |
209 | return -EINVAL; | |
210 | ||
211 | break; | |
212 | ||
213 | case TELEM_ADD: | |
214 | if ((len + unit_config->ssram_evts_used) > | |
215 | TELEM_MAX_EVENTS_SRAM) | |
216 | return -EINVAL; | |
217 | ||
218 | if ((len > 0) && (evtmap == NULL)) | |
219 | return -EINVAL; | |
220 | ||
221 | break; | |
222 | ||
223 | default: | |
224 | pr_err("Unknown Telemetry action Specified %d\n", action); | |
225 | return -EINVAL; | |
226 | } | |
227 | ||
228 | return 0; | |
229 | } | |
230 | ||
231 | ||
232 | static inline int telemetry_plt_config_ioss_event(u32 evt_id, int index) | |
233 | { | |
234 | u32 write_buf; | |
235 | int ret; | |
236 | ||
237 | write_buf = evt_id | TELEM_EVENT_ENABLE; | |
238 | write_buf <<= BITS_PER_BYTE; | |
239 | write_buf |= index; | |
240 | ||
241 | ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY, | |
242 | IOSS_TELEM_EVENT_WRITE, (u8 *)&write_buf, | |
243 | IOSS_TELEM_EVT_WRITE_SIZE, NULL, 0); | |
244 | ||
245 | return ret; | |
246 | } | |
247 | ||
248 | static inline int telemetry_plt_config_pss_event(u32 evt_id, int index) | |
249 | { | |
250 | u32 write_buf; | |
251 | int ret; | |
252 | ||
253 | write_buf = evt_id | TELEM_EVENT_ENABLE; | |
254 | ret = intel_punit_ipc_command(IPC_PUNIT_BIOS_WRITE_TELE_EVENT, | |
255 | index, 0, &write_buf, NULL); | |
256 | ||
257 | return ret; | |
258 | } | |
259 | ||
260 | static int telemetry_setup_iossevtconfig(struct telemetry_evtconfig evtconfig, | |
261 | enum telemetry_action action) | |
262 | { | |
263 | u8 num_ioss_evts, ioss_period; | |
264 | int ret, index, idx; | |
265 | u32 *ioss_evtmap; | |
266 | u32 telem_ctrl; | |
267 | ||
268 | num_ioss_evts = evtconfig.num_evts; | |
269 | ioss_period = evtconfig.period; | |
270 | ioss_evtmap = evtconfig.evtmap; | |
271 | ||
272 | /* Get telemetry EVENT CTL */ | |
273 | ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY, | |
274 | IOSS_TELEM_EVENT_CTL_READ, NULL, 0, | |
275 | &telem_ctrl, IOSS_TELEM_READ_WORD); | |
276 | if (ret) { | |
277 | pr_err("IOSS TELEM_CTRL Read Failed\n"); | |
278 | return ret; | |
279 | } | |
280 | ||
281 | /* Disable Telemetry */ | |
282 | TELEM_DISABLE(telem_ctrl); | |
283 | ||
284 | ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY, | |
285 | IOSS_TELEM_EVENT_CTL_WRITE, | |
286 | (u8 *)&telem_ctrl, | |
287 | IOSS_TELEM_EVT_CTRL_WRITE_SIZE, | |
288 | NULL, 0); | |
289 | if (ret) { | |
290 | pr_err("IOSS TELEM_CTRL Event Disable Write Failed\n"); | |
291 | return ret; | |
292 | } | |
293 | ||
294 | ||
295 | /* Reset Everything */ | |
296 | if (action == TELEM_RESET) { | |
297 | /* Clear All Events */ | |
298 | TELEM_CLEAR_EVENTS(telem_ctrl); | |
299 | ||
300 | ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY, | |
301 | IOSS_TELEM_EVENT_CTL_WRITE, | |
302 | (u8 *)&telem_ctrl, | |
303 | IOSS_TELEM_EVT_CTRL_WRITE_SIZE, | |
304 | NULL, 0); | |
305 | if (ret) { | |
306 | pr_err("IOSS TELEM_CTRL Event Disable Write Failed\n"); | |
307 | return ret; | |
308 | } | |
309 | telm_conf->ioss_config.ssram_evts_used = 0; | |
310 | ||
311 | /* Configure Events */ | |
312 | for (idx = 0; idx < num_ioss_evts; idx++) { | |
313 | if (telemetry_plt_config_ioss_event( | |
314 | telm_conf->ioss_config.telem_evts[idx].evt_id, | |
315 | idx)) { | |
316 | pr_err("IOSS TELEM_RESET Fail for data: %x\n", | |
317 | telm_conf->ioss_config.telem_evts[idx].evt_id); | |
318 | continue; | |
319 | } | |
320 | telm_conf->ioss_config.ssram_evts_used++; | |
321 | } | |
322 | } | |
323 | ||
324 | /* Re-Configure Everything */ | |
325 | if (action == TELEM_UPDATE) { | |
326 | /* Clear All Events */ | |
327 | TELEM_CLEAR_EVENTS(telem_ctrl); | |
328 | ||
329 | ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY, | |
330 | IOSS_TELEM_EVENT_CTL_WRITE, | |
331 | (u8 *)&telem_ctrl, | |
332 | IOSS_TELEM_EVT_CTRL_WRITE_SIZE, | |
333 | NULL, 0); | |
334 | if (ret) { | |
335 | pr_err("IOSS TELEM_CTRL Event Disable Write Failed\n"); | |
336 | return ret; | |
337 | } | |
338 | telm_conf->ioss_config.ssram_evts_used = 0; | |
339 | ||
340 | /* Configure Events */ | |
341 | for (index = 0; index < num_ioss_evts; index++) { | |
342 | telm_conf->ioss_config.telem_evts[index].evt_id = | |
343 | ioss_evtmap[index]; | |
344 | ||
345 | if (telemetry_plt_config_ioss_event( | |
346 | telm_conf->ioss_config.telem_evts[index].evt_id, | |
347 | index)) { | |
348 | pr_err("IOSS TELEM_UPDATE Fail for Evt%x\n", | |
349 | ioss_evtmap[index]); | |
350 | continue; | |
351 | } | |
352 | telm_conf->ioss_config.ssram_evts_used++; | |
353 | } | |
354 | } | |
355 | ||
356 | /* Add some Events */ | |
357 | if (action == TELEM_ADD) { | |
358 | /* Configure Events */ | |
359 | for (index = telm_conf->ioss_config.ssram_evts_used, idx = 0; | |
360 | idx < num_ioss_evts; index++, idx++) { | |
361 | telm_conf->ioss_config.telem_evts[index].evt_id = | |
362 | ioss_evtmap[idx]; | |
363 | ||
364 | if (telemetry_plt_config_ioss_event( | |
365 | telm_conf->ioss_config.telem_evts[index].evt_id, | |
366 | index)) { | |
367 | pr_err("IOSS TELEM_ADD Fail for Event %x\n", | |
368 | ioss_evtmap[idx]); | |
369 | continue; | |
370 | } | |
371 | telm_conf->ioss_config.ssram_evts_used++; | |
372 | } | |
373 | } | |
374 | ||
375 | /* Enable Periodic Telemetry Events and enable SRAM trace */ | |
376 | TELEM_CLEAR_SAMPLE_PERIOD(telem_ctrl); | |
377 | TELEM_ENABLE_SRAM_EVT_TRACE(telem_ctrl); | |
378 | TELEM_ENABLE_PERIODIC(telem_ctrl); | |
379 | telem_ctrl |= ioss_period; | |
380 | ||
381 | ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY, | |
382 | IOSS_TELEM_EVENT_CTL_WRITE, | |
383 | (u8 *)&telem_ctrl, | |
384 | IOSS_TELEM_EVT_CTRL_WRITE_SIZE, NULL, 0); | |
385 | if (ret) { | |
386 | pr_err("IOSS TELEM_CTRL Event Enable Write Failed\n"); | |
387 | return ret; | |
388 | } | |
389 | ||
390 | telm_conf->ioss_config.curr_period = ioss_period; | |
391 | ||
392 | return 0; | |
393 | } | |
394 | ||
395 | ||
396 | static int telemetry_setup_pssevtconfig(struct telemetry_evtconfig evtconfig, | |
397 | enum telemetry_action action) | |
398 | { | |
399 | u8 num_pss_evts, pss_period; | |
400 | int ret, index, idx; | |
401 | u32 *pss_evtmap; | |
402 | u32 telem_ctrl; | |
403 | ||
404 | num_pss_evts = evtconfig.num_evts; | |
405 | pss_period = evtconfig.period; | |
406 | pss_evtmap = evtconfig.evtmap; | |
407 | ||
408 | /* PSS Config */ | |
409 | /* Get telemetry EVENT CTL */ | |
410 | ret = intel_punit_ipc_command(IPC_PUNIT_BIOS_READ_TELE_EVENT_CTRL, | |
411 | 0, 0, NULL, &telem_ctrl); | |
412 | if (ret) { | |
413 | pr_err("PSS TELEM_CTRL Read Failed\n"); | |
414 | return ret; | |
415 | } | |
416 | ||
417 | /* Disable Telemetry */ | |
418 | TELEM_DISABLE(telem_ctrl); | |
419 | ret = intel_punit_ipc_command(IPC_PUNIT_BIOS_WRITE_TELE_EVENT_CTRL, | |
420 | 0, 0, &telem_ctrl, NULL); | |
421 | if (ret) { | |
422 | pr_err("PSS TELEM_CTRL Event Disable Write Failed\n"); | |
423 | return ret; | |
424 | } | |
425 | ||
426 | /* Reset Everything */ | |
427 | if (action == TELEM_RESET) { | |
428 | /* Clear All Events */ | |
429 | TELEM_CLEAR_EVENTS(telem_ctrl); | |
430 | ||
431 | ret = intel_punit_ipc_command( | |
432 | IPC_PUNIT_BIOS_WRITE_TELE_EVENT_CTRL, | |
433 | 0, 0, &telem_ctrl, NULL); | |
434 | if (ret) { | |
435 | pr_err("PSS TELEM_CTRL Event Disable Write Failed\n"); | |
436 | return ret; | |
437 | } | |
438 | telm_conf->pss_config.ssram_evts_used = 0; | |
439 | /* Configure Events */ | |
440 | for (idx = 0; idx < num_pss_evts; idx++) { | |
441 | if (telemetry_plt_config_pss_event( | |
442 | telm_conf->pss_config.telem_evts[idx].evt_id, | |
443 | idx)) { | |
444 | pr_err("PSS TELEM_RESET Fail for Event %x\n", | |
445 | telm_conf->pss_config.telem_evts[idx].evt_id); | |
446 | continue; | |
447 | } | |
448 | telm_conf->pss_config.ssram_evts_used++; | |
449 | } | |
450 | } | |
451 | ||
452 | /* Re-Configure Everything */ | |
453 | if (action == TELEM_UPDATE) { | |
454 | /* Clear All Events */ | |
455 | TELEM_CLEAR_EVENTS(telem_ctrl); | |
456 | ||
457 | ret = intel_punit_ipc_command( | |
458 | IPC_PUNIT_BIOS_WRITE_TELE_EVENT_CTRL, | |
459 | 0, 0, &telem_ctrl, NULL); | |
460 | if (ret) { | |
461 | pr_err("PSS TELEM_CTRL Event Disable Write Failed\n"); | |
462 | return ret; | |
463 | } | |
464 | telm_conf->pss_config.ssram_evts_used = 0; | |
465 | ||
466 | /* Configure Events */ | |
467 | for (index = 0; index < num_pss_evts; index++) { | |
468 | telm_conf->pss_config.telem_evts[index].evt_id = | |
469 | pss_evtmap[index]; | |
470 | ||
471 | if (telemetry_plt_config_pss_event( | |
472 | telm_conf->pss_config.telem_evts[index].evt_id, | |
473 | index)) { | |
474 | pr_err("PSS TELEM_UPDATE Fail for Event %x\n", | |
475 | pss_evtmap[index]); | |
476 | continue; | |
477 | } | |
478 | telm_conf->pss_config.ssram_evts_used++; | |
479 | } | |
480 | } | |
481 | ||
482 | /* Add some Events */ | |
483 | if (action == TELEM_ADD) { | |
484 | /* Configure Events */ | |
485 | for (index = telm_conf->pss_config.ssram_evts_used, idx = 0; | |
486 | idx < num_pss_evts; index++, idx++) { | |
487 | ||
488 | telm_conf->pss_config.telem_evts[index].evt_id = | |
489 | pss_evtmap[idx]; | |
490 | ||
491 | if (telemetry_plt_config_pss_event( | |
492 | telm_conf->pss_config.telem_evts[index].evt_id, | |
493 | index)) { | |
494 | pr_err("PSS TELEM_ADD Fail for Event %x\n", | |
495 | pss_evtmap[idx]); | |
496 | continue; | |
497 | } | |
498 | telm_conf->pss_config.ssram_evts_used++; | |
499 | } | |
500 | } | |
501 | ||
502 | /* Enable Periodic Telemetry Events and enable SRAM trace */ | |
503 | TELEM_CLEAR_SAMPLE_PERIOD(telem_ctrl); | |
504 | TELEM_ENABLE_SRAM_EVT_TRACE(telem_ctrl); | |
505 | TELEM_ENABLE_PERIODIC(telem_ctrl); | |
506 | telem_ctrl |= pss_period; | |
507 | ||
508 | ret = intel_punit_ipc_command(IPC_PUNIT_BIOS_WRITE_TELE_EVENT_CTRL, | |
509 | 0, 0, &telem_ctrl, NULL); | |
510 | if (ret) { | |
511 | pr_err("PSS TELEM_CTRL Event Enable Write Failed\n"); | |
512 | return ret; | |
513 | } | |
514 | ||
515 | telm_conf->pss_config.curr_period = pss_period; | |
516 | ||
517 | return 0; | |
518 | } | |
519 | ||
520 | static int telemetry_setup_evtconfig(struct telemetry_evtconfig pss_evtconfig, | |
521 | struct telemetry_evtconfig ioss_evtconfig, | |
522 | enum telemetry_action action) | |
523 | { | |
524 | int ret; | |
525 | ||
526 | mutex_lock(&(telm_conf->telem_lock)); | |
527 | ||
528 | if ((action == TELEM_UPDATE) && (telm_conf->telem_in_use)) { | |
529 | ret = -EBUSY; | |
530 | goto out; | |
531 | } | |
532 | ||
533 | ret = telemetry_check_evtid(TELEM_PSS, pss_evtconfig.evtmap, | |
534 | pss_evtconfig.num_evts, action); | |
535 | if (ret) | |
536 | goto out; | |
537 | ||
538 | ret = telemetry_check_evtid(TELEM_IOSS, ioss_evtconfig.evtmap, | |
539 | ioss_evtconfig.num_evts, action); | |
540 | if (ret) | |
541 | goto out; | |
542 | ||
543 | if (ioss_evtconfig.num_evts) { | |
544 | ret = telemetry_setup_iossevtconfig(ioss_evtconfig, action); | |
545 | if (ret) | |
546 | goto out; | |
547 | } | |
548 | ||
549 | if (pss_evtconfig.num_evts) { | |
550 | ret = telemetry_setup_pssevtconfig(pss_evtconfig, action); | |
551 | if (ret) | |
552 | goto out; | |
553 | } | |
554 | ||
555 | if ((action == TELEM_UPDATE) || (action == TELEM_ADD)) | |
556 | telm_conf->telem_in_use = true; | |
557 | else | |
558 | telm_conf->telem_in_use = false; | |
559 | ||
560 | out: | |
561 | mutex_unlock(&(telm_conf->telem_lock)); | |
562 | return ret; | |
563 | } | |
564 | ||
565 | static int telemetry_setup(struct platform_device *pdev) | |
566 | { | |
567 | struct telemetry_evtconfig pss_evtconfig, ioss_evtconfig; | |
568 | u32 read_buf, events, event_regs; | |
569 | int ret; | |
570 | ||
571 | ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY, IOSS_TELEM_INFO_READ, | |
572 | NULL, 0, &read_buf, IOSS_TELEM_READ_WORD); | |
573 | if (ret) { | |
574 | dev_err(&pdev->dev, "IOSS TELEM_INFO Read Failed\n"); | |
575 | return ret; | |
576 | } | |
577 | ||
578 | /* Get telemetry Info */ | |
579 | events = (read_buf & TELEM_INFO_SRAMEVTS_MASK) >> | |
580 | TELEM_INFO_SRAMEVTS_SHIFT; | |
581 | event_regs = read_buf & TELEM_INFO_NENABLES_MASK; | |
582 | if ((events < TELEM_MAX_EVENTS_SRAM) || | |
583 | (event_regs < TELEM_MAX_EVENTS_SRAM)) { | |
584 | dev_err(&pdev->dev, "IOSS:Insufficient Space for SRAM Trace\n"); | |
585 | dev_err(&pdev->dev, "SRAM Events %d; Event Regs %d\n", | |
586 | events, event_regs); | |
587 | return -ENOMEM; | |
588 | } | |
589 | ||
590 | telm_conf->ioss_config.min_period = TELEM_MIN_PERIOD(read_buf); | |
591 | telm_conf->ioss_config.max_period = TELEM_MAX_PERIOD(read_buf); | |
592 | ||
593 | /* PUNIT Mailbox Setup */ | |
594 | ret = intel_punit_ipc_command(IPC_PUNIT_BIOS_READ_TELE_INFO, 0, 0, | |
595 | NULL, &read_buf); | |
596 | if (ret) { | |
597 | dev_err(&pdev->dev, "PSS TELEM_INFO Read Failed\n"); | |
598 | return ret; | |
599 | } | |
600 | ||
601 | /* Get telemetry Info */ | |
602 | events = (read_buf & TELEM_INFO_SRAMEVTS_MASK) >> | |
603 | TELEM_INFO_SRAMEVTS_SHIFT; | |
604 | event_regs = read_buf & TELEM_INFO_SRAMEVTS_MASK; | |
605 | if ((events < TELEM_MAX_EVENTS_SRAM) || | |
606 | (event_regs < TELEM_MAX_EVENTS_SRAM)) { | |
607 | dev_err(&pdev->dev, "PSS:Insufficient Space for SRAM Trace\n"); | |
608 | dev_err(&pdev->dev, "SRAM Events %d; Event Regs %d\n", | |
609 | events, event_regs); | |
610 | return -ENOMEM; | |
611 | } | |
612 | ||
613 | telm_conf->pss_config.min_period = TELEM_MIN_PERIOD(read_buf); | |
614 | telm_conf->pss_config.max_period = TELEM_MAX_PERIOD(read_buf); | |
615 | ||
616 | pss_evtconfig.evtmap = NULL; | |
617 | pss_evtconfig.num_evts = TELEM_MAX_OS_ALLOCATED_EVENTS; | |
618 | pss_evtconfig.period = TELEM_SAMPLING_DEFAULT_PERIOD; | |
619 | ||
620 | ioss_evtconfig.evtmap = NULL; | |
621 | ioss_evtconfig.num_evts = TELEM_MAX_OS_ALLOCATED_EVENTS; | |
622 | ioss_evtconfig.period = TELEM_SAMPLING_DEFAULT_PERIOD; | |
623 | ||
624 | ret = telemetry_setup_evtconfig(pss_evtconfig, ioss_evtconfig, | |
625 | TELEM_RESET); | |
626 | if (ret) { | |
627 | dev_err(&pdev->dev, "TELEMTRY Setup Failed\n"); | |
628 | return ret; | |
629 | } | |
630 | return 0; | |
631 | } | |
632 | ||
633 | static int telemetry_plt_update_events(struct telemetry_evtconfig pss_evtconfig, | |
634 | struct telemetry_evtconfig ioss_evtconfig) | |
635 | { | |
636 | int ret; | |
637 | ||
638 | if ((pss_evtconfig.num_evts > 0) && | |
639 | (TELEM_SAMPLE_PERIOD_INVALID(pss_evtconfig.period))) { | |
640 | pr_err("PSS Sampling Period Out of Range\n"); | |
641 | return -EINVAL; | |
642 | } | |
643 | ||
644 | if ((ioss_evtconfig.num_evts > 0) && | |
645 | (TELEM_SAMPLE_PERIOD_INVALID(ioss_evtconfig.period))) { | |
646 | pr_err("IOSS Sampling Period Out of Range\n"); | |
647 | return -EINVAL; | |
648 | } | |
649 | ||
650 | ret = telemetry_setup_evtconfig(pss_evtconfig, ioss_evtconfig, | |
651 | TELEM_UPDATE); | |
652 | if (ret) | |
653 | pr_err("TELEMTRY Config Failed\n"); | |
654 | ||
655 | return ret; | |
656 | } | |
657 | ||
658 | ||
659 | static int telemetry_plt_set_sampling_period(u8 pss_period, u8 ioss_period) | |
660 | { | |
661 | u32 telem_ctrl = 0; | |
662 | int ret; | |
663 | ||
664 | mutex_lock(&(telm_conf->telem_lock)); | |
665 | if (ioss_period) { | |
666 | if (TELEM_SAMPLE_PERIOD_INVALID(ioss_period)) { | |
667 | pr_err("IOSS Sampling Period Out of Range\n"); | |
668 | ret = -EINVAL; | |
669 | goto out; | |
670 | } | |
671 | ||
672 | /* Get telemetry EVENT CTL */ | |
673 | ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY, | |
674 | IOSS_TELEM_EVENT_CTL_READ, NULL, 0, | |
675 | &telem_ctrl, IOSS_TELEM_READ_WORD); | |
676 | if (ret) { | |
677 | pr_err("IOSS TELEM_CTRL Read Failed\n"); | |
678 | goto out; | |
679 | } | |
680 | ||
681 | /* Disable Telemetry */ | |
682 | TELEM_DISABLE(telem_ctrl); | |
683 | ||
684 | ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY, | |
685 | IOSS_TELEM_EVENT_CTL_WRITE, | |
686 | (u8 *)&telem_ctrl, | |
687 | IOSS_TELEM_EVT_CTRL_WRITE_SIZE, | |
688 | NULL, 0); | |
689 | if (ret) { | |
690 | pr_err("IOSS TELEM_CTRL Event Disable Write Failed\n"); | |
691 | goto out; | |
692 | } | |
693 | ||
694 | /* Enable Periodic Telemetry Events and enable SRAM trace */ | |
695 | TELEM_CLEAR_SAMPLE_PERIOD(telem_ctrl); | |
696 | TELEM_ENABLE_SRAM_EVT_TRACE(telem_ctrl); | |
697 | TELEM_ENABLE_PERIODIC(telem_ctrl); | |
698 | telem_ctrl |= ioss_period; | |
699 | ||
700 | ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY, | |
701 | IOSS_TELEM_EVENT_CTL_WRITE, | |
702 | (u8 *)&telem_ctrl, | |
703 | IOSS_TELEM_EVT_CTRL_WRITE_SIZE, | |
704 | NULL, 0); | |
705 | if (ret) { | |
706 | pr_err("IOSS TELEM_CTRL Event Enable Write Failed\n"); | |
707 | goto out; | |
708 | } | |
709 | telm_conf->ioss_config.curr_period = ioss_period; | |
710 | } | |
711 | ||
712 | if (pss_period) { | |
713 | if (TELEM_SAMPLE_PERIOD_INVALID(pss_period)) { | |
714 | pr_err("PSS Sampling Period Out of Range\n"); | |
715 | ret = -EINVAL; | |
716 | goto out; | |
717 | } | |
718 | ||
719 | /* Get telemetry EVENT CTL */ | |
720 | ret = intel_punit_ipc_command( | |
721 | IPC_PUNIT_BIOS_READ_TELE_EVENT_CTRL, | |
722 | 0, 0, NULL, &telem_ctrl); | |
723 | if (ret) { | |
724 | pr_err("PSS TELEM_CTRL Read Failed\n"); | |
725 | goto out; | |
726 | } | |
727 | ||
728 | /* Disable Telemetry */ | |
729 | TELEM_DISABLE(telem_ctrl); | |
730 | ret = intel_punit_ipc_command( | |
731 | IPC_PUNIT_BIOS_WRITE_TELE_EVENT_CTRL, | |
732 | 0, 0, &telem_ctrl, NULL); | |
733 | if (ret) { | |
734 | pr_err("PSS TELEM_CTRL Event Disable Write Failed\n"); | |
735 | goto out; | |
736 | } | |
737 | ||
738 | /* Enable Periodic Telemetry Events and enable SRAM trace */ | |
739 | TELEM_CLEAR_SAMPLE_PERIOD(telem_ctrl); | |
740 | TELEM_ENABLE_SRAM_EVT_TRACE(telem_ctrl); | |
741 | TELEM_ENABLE_PERIODIC(telem_ctrl); | |
742 | telem_ctrl |= pss_period; | |
743 | ||
744 | ret = intel_punit_ipc_command( | |
745 | IPC_PUNIT_BIOS_WRITE_TELE_EVENT_CTRL, | |
746 | 0, 0, &telem_ctrl, NULL); | |
747 | if (ret) { | |
748 | pr_err("PSS TELEM_CTRL Event Enable Write Failed\n"); | |
749 | goto out; | |
750 | } | |
751 | telm_conf->pss_config.curr_period = pss_period; | |
752 | } | |
753 | ||
754 | out: | |
755 | mutex_unlock(&(telm_conf->telem_lock)); | |
756 | return ret; | |
757 | } | |
758 | ||
759 | ||
760 | static int telemetry_plt_get_sampling_period(u8 *pss_min_period, | |
761 | u8 *pss_max_period, | |
762 | u8 *ioss_min_period, | |
763 | u8 *ioss_max_period) | |
764 | { | |
765 | *pss_min_period = telm_conf->pss_config.min_period; | |
766 | *pss_max_period = telm_conf->pss_config.max_period; | |
767 | *ioss_min_period = telm_conf->ioss_config.min_period; | |
768 | *ioss_max_period = telm_conf->ioss_config.max_period; | |
769 | ||
770 | return 0; | |
771 | } | |
772 | ||
773 | ||
774 | static int telemetry_plt_reset_events(void) | |
775 | { | |
776 | struct telemetry_evtconfig pss_evtconfig, ioss_evtconfig; | |
777 | int ret; | |
778 | ||
779 | pss_evtconfig.evtmap = NULL; | |
780 | pss_evtconfig.num_evts = TELEM_MAX_OS_ALLOCATED_EVENTS; | |
781 | pss_evtconfig.period = TELEM_SAMPLING_DEFAULT_PERIOD; | |
782 | ||
783 | ioss_evtconfig.evtmap = NULL; | |
784 | ioss_evtconfig.num_evts = TELEM_MAX_OS_ALLOCATED_EVENTS; | |
785 | ioss_evtconfig.period = TELEM_SAMPLING_DEFAULT_PERIOD; | |
786 | ||
787 | ret = telemetry_setup_evtconfig(pss_evtconfig, ioss_evtconfig, | |
788 | TELEM_RESET); | |
789 | if (ret) | |
790 | pr_err("TELEMTRY Reset Failed\n"); | |
791 | ||
792 | return ret; | |
793 | } | |
794 | ||
795 | ||
796 | static int telemetry_plt_get_eventconfig(struct telemetry_evtconfig *pss_config, | |
797 | struct telemetry_evtconfig *ioss_config, | |
798 | int pss_len, int ioss_len) | |
799 | { | |
800 | u32 *pss_evtmap, *ioss_evtmap; | |
801 | u32 index; | |
802 | ||
803 | pss_evtmap = pss_config->evtmap; | |
804 | ioss_evtmap = ioss_config->evtmap; | |
805 | ||
806 | mutex_lock(&(telm_conf->telem_lock)); | |
807 | pss_config->num_evts = telm_conf->pss_config.ssram_evts_used; | |
808 | ioss_config->num_evts = telm_conf->ioss_config.ssram_evts_used; | |
809 | ||
810 | pss_config->period = telm_conf->pss_config.curr_period; | |
811 | ioss_config->period = telm_conf->ioss_config.curr_period; | |
812 | ||
813 | if ((pss_len < telm_conf->pss_config.ssram_evts_used) || | |
814 | (ioss_len < telm_conf->ioss_config.ssram_evts_used)) { | |
815 | mutex_unlock(&(telm_conf->telem_lock)); | |
816 | return -EINVAL; | |
817 | } | |
818 | ||
819 | for (index = 0; index < telm_conf->pss_config.ssram_evts_used; | |
820 | index++) { | |
821 | pss_evtmap[index] = | |
822 | telm_conf->pss_config.telem_evts[index].evt_id; | |
823 | } | |
824 | ||
825 | for (index = 0; index < telm_conf->ioss_config.ssram_evts_used; | |
826 | index++) { | |
827 | ioss_evtmap[index] = | |
828 | telm_conf->ioss_config.telem_evts[index].evt_id; | |
829 | } | |
830 | ||
831 | mutex_unlock(&(telm_conf->telem_lock)); | |
832 | return 0; | |
833 | } | |
834 | ||
835 | ||
836 | static int telemetry_plt_add_events(u8 num_pss_evts, u8 num_ioss_evts, | |
837 | u32 *pss_evtmap, u32 *ioss_evtmap) | |
838 | { | |
839 | struct telemetry_evtconfig pss_evtconfig, ioss_evtconfig; | |
840 | int ret; | |
841 | ||
842 | pss_evtconfig.evtmap = pss_evtmap; | |
843 | pss_evtconfig.num_evts = num_pss_evts; | |
844 | pss_evtconfig.period = telm_conf->pss_config.curr_period; | |
845 | ||
846 | ioss_evtconfig.evtmap = ioss_evtmap; | |
847 | ioss_evtconfig.num_evts = num_ioss_evts; | |
848 | ioss_evtconfig.period = telm_conf->ioss_config.curr_period; | |
849 | ||
850 | ret = telemetry_setup_evtconfig(pss_evtconfig, ioss_evtconfig, | |
851 | TELEM_ADD); | |
852 | if (ret) | |
853 | pr_err("TELEMTRY ADD Failed\n"); | |
854 | ||
855 | return ret; | |
856 | } | |
857 | ||
858 | static int telem_evtlog_read(enum telemetry_unit telem_unit, | |
859 | struct telem_ssram_region *ssram_region, u8 len) | |
860 | { | |
861 | struct telemetry_unit_config *unit_config; | |
862 | u64 timestamp_prev, timestamp_next; | |
863 | int ret, index, timeout = 0; | |
864 | ||
865 | ret = telem_get_unitconfig(telem_unit, &unit_config); | |
866 | if (ret < 0) | |
867 | return ret; | |
868 | ||
869 | if (len > unit_config->ssram_evts_used) | |
870 | len = unit_config->ssram_evts_used; | |
871 | ||
872 | do { | |
873 | timestamp_prev = readq(unit_config->regmap); | |
874 | if (!timestamp_prev) { | |
875 | pr_err("Ssram under update. Please Try Later\n"); | |
876 | return -EBUSY; | |
877 | } | |
878 | ||
879 | ssram_region->start_time = readq(unit_config->regmap + | |
880 | TELEM_SSRAM_STARTTIME_OFFSET); | |
881 | ||
882 | for (index = 0; index < len; index++) { | |
883 | ssram_region->events[index] = | |
884 | readq(unit_config->regmap + TELEM_SSRAM_EVTLOG_OFFSET + | |
885 | BYTES_PER_LONG*index); | |
886 | } | |
887 | ||
888 | timestamp_next = readq(unit_config->regmap); | |
889 | if (!timestamp_next) { | |
890 | pr_err("Ssram under update. Please Try Later\n"); | |
891 | return -EBUSY; | |
892 | } | |
893 | ||
894 | if (timeout++ > TELEM_SSRAM_READ_TIMEOUT) { | |
895 | pr_err("Timeout while reading Events\n"); | |
896 | return -EBUSY; | |
897 | } | |
898 | ||
899 | } while (timestamp_prev != timestamp_next); | |
900 | ||
901 | ssram_region->timestamp = timestamp_next; | |
902 | ||
903 | return len; | |
904 | } | |
905 | ||
906 | static int telemetry_plt_raw_read_eventlog(enum telemetry_unit telem_unit, | |
907 | struct telemetry_evtlog *evtlog, | |
908 | int len, int log_all_evts) | |
909 | { | |
910 | int index, idx1, ret, readlen = len; | |
911 | struct telem_ssram_region ssram_region; | |
912 | struct telemetry_evtmap *evtmap; | |
913 | ||
914 | switch (telem_unit) { | |
915 | case TELEM_PSS: | |
916 | evtmap = telm_conf->pss_config.telem_evts; | |
917 | break; | |
918 | ||
919 | case TELEM_IOSS: | |
920 | evtmap = telm_conf->ioss_config.telem_evts; | |
921 | break; | |
922 | ||
923 | default: | |
924 | pr_err("Unknown Telemetry Unit Specified %d\n", telem_unit); | |
925 | return -EINVAL; | |
926 | } | |
927 | ||
928 | if (!log_all_evts) | |
929 | readlen = TELEM_MAX_EVENTS_SRAM; | |
930 | ||
931 | ret = telem_evtlog_read(telem_unit, &ssram_region, readlen); | |
932 | if (ret < 0) | |
933 | return ret; | |
934 | ||
935 | /* Invalid evt-id array specified via length mismatch */ | |
936 | if ((!log_all_evts) && (len > ret)) | |
937 | return -EINVAL; | |
938 | ||
939 | if (log_all_evts) | |
940 | for (index = 0; index < ret; index++) { | |
941 | evtlog[index].telem_evtlog = ssram_region.events[index]; | |
942 | evtlog[index].telem_evtid = evtmap[index].evt_id; | |
943 | } | |
944 | else | |
945 | for (index = 0, readlen = 0; (index < ret) && (readlen < len); | |
946 | index++) { | |
947 | for (idx1 = 0; idx1 < len; idx1++) { | |
948 | /* Elements matched */ | |
949 | if (evtmap[index].evt_id == | |
950 | evtlog[idx1].telem_evtid) { | |
951 | evtlog[idx1].telem_evtlog = | |
952 | ssram_region.events[index]; | |
953 | readlen++; | |
954 | ||
955 | break; | |
956 | } | |
957 | } | |
958 | } | |
959 | ||
960 | return readlen; | |
961 | } | |
962 | ||
963 | static int telemetry_plt_read_eventlog(enum telemetry_unit telem_unit, | |
964 | struct telemetry_evtlog *evtlog, int len, int log_all_evts) | |
965 | { | |
966 | int ret; | |
967 | ||
968 | mutex_lock(&(telm_conf->telem_lock)); | |
969 | ret = telemetry_plt_raw_read_eventlog(telem_unit, evtlog, | |
970 | len, log_all_evts); | |
971 | mutex_unlock(&(telm_conf->telem_lock)); | |
972 | ||
973 | return ret; | |
974 | } | |
975 | ||
976 | static int telemetry_plt_get_trace_verbosity(enum telemetry_unit telem_unit, | |
977 | u32 *verbosity) | |
978 | { | |
979 | u32 temp = 0; | |
980 | int ret; | |
981 | ||
982 | if (verbosity == NULL) | |
983 | return -EINVAL; | |
984 | ||
985 | mutex_lock(&(telm_conf->telem_trace_lock)); | |
986 | switch (telem_unit) { | |
987 | case TELEM_PSS: | |
988 | ret = intel_punit_ipc_command( | |
989 | IPC_PUNIT_BIOS_READ_TELE_TRACE_CTRL, | |
990 | 0, 0, NULL, &temp); | |
991 | if (ret) { | |
992 | pr_err("PSS TRACE_CTRL Read Failed\n"); | |
993 | goto out; | |
994 | } | |
995 | ||
996 | break; | |
997 | ||
998 | case TELEM_IOSS: | |
999 | ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY, | |
1000 | IOSS_TELEM_TRACE_CTL_READ, NULL, 0, &temp, | |
1001 | IOSS_TELEM_READ_WORD); | |
1002 | if (ret) { | |
1003 | pr_err("IOSS TRACE_CTL Read Failed\n"); | |
1004 | goto out; | |
1005 | } | |
1006 | ||
1007 | break; | |
1008 | ||
1009 | default: | |
1010 | pr_err("Unknown Telemetry Unit Specified %d\n", telem_unit); | |
1011 | ret = -EINVAL; | |
1012 | break; | |
1013 | } | |
1014 | TELEM_EXTRACT_VERBOSITY(temp, *verbosity); | |
1015 | ||
1016 | out: | |
1017 | mutex_unlock(&(telm_conf->telem_trace_lock)); | |
1018 | return ret; | |
1019 | } | |
1020 | ||
1021 | static int telemetry_plt_set_trace_verbosity(enum telemetry_unit telem_unit, | |
1022 | u32 verbosity) | |
1023 | { | |
1024 | u32 temp = 0; | |
1025 | int ret; | |
1026 | ||
1027 | verbosity &= TELEM_TRC_VERBOSITY_MASK; | |
1028 | ||
1029 | mutex_lock(&(telm_conf->telem_trace_lock)); | |
1030 | switch (telem_unit) { | |
1031 | case TELEM_PSS: | |
1032 | ret = intel_punit_ipc_command( | |
1033 | IPC_PUNIT_BIOS_WRITE_TELE_TRACE_CTRL, | |
1034 | 0, 0, &verbosity, NULL); | |
1035 | if (ret) { | |
1036 | pr_err("PSS TRACE_CTRL Verbosity Set Failed\n"); | |
1037 | goto out; | |
1038 | } | |
1039 | break; | |
1040 | ||
1041 | case TELEM_IOSS: | |
1042 | ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY, | |
1043 | IOSS_TELEM_TRACE_CTL_READ, NULL, 0, &temp, | |
1044 | IOSS_TELEM_READ_WORD); | |
1045 | if (ret) { | |
1046 | pr_err("IOSS TRACE_CTL Read Failed\n"); | |
1047 | goto out; | |
1048 | } | |
1049 | ||
1050 | TELEM_CLEAR_VERBOSITY_BITS(temp); | |
1051 | TELEM_SET_VERBOSITY_BITS(temp, verbosity); | |
1052 | ||
1053 | ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY, | |
1054 | IOSS_TELEM_TRACE_CTL_WRITE, (u8 *)&temp, | |
1055 | IOSS_TELEM_WRITE_FOURBYTES, NULL, 0); | |
1056 | if (ret) { | |
1057 | pr_err("IOSS TRACE_CTL Verbosity Set Failed\n"); | |
1058 | goto out; | |
1059 | } | |
1060 | break; | |
1061 | ||
1062 | default: | |
1063 | pr_err("Unknown Telemetry Unit Specified %d\n", telem_unit); | |
1064 | ret = -EINVAL; | |
1065 | break; | |
1066 | } | |
1067 | ||
1068 | out: | |
1069 | mutex_unlock(&(telm_conf->telem_trace_lock)); | |
1070 | return ret; | |
1071 | } | |
1072 | ||
1073 | static struct telemetry_core_ops telm_pltops = { | |
1074 | .get_trace_verbosity = telemetry_plt_get_trace_verbosity, | |
1075 | .set_trace_verbosity = telemetry_plt_set_trace_verbosity, | |
1076 | .set_sampling_period = telemetry_plt_set_sampling_period, | |
1077 | .get_sampling_period = telemetry_plt_get_sampling_period, | |
1078 | .raw_read_eventlog = telemetry_plt_raw_read_eventlog, | |
1079 | .get_eventconfig = telemetry_plt_get_eventconfig, | |
1080 | .update_events = telemetry_plt_update_events, | |
1081 | .read_eventlog = telemetry_plt_read_eventlog, | |
1082 | .reset_events = telemetry_plt_reset_events, | |
1083 | .add_events = telemetry_plt_add_events, | |
1084 | }; | |
1085 | ||
1086 | static int telemetry_pltdrv_probe(struct platform_device *pdev) | |
1087 | { | |
1088 | struct resource *res0 = NULL, *res1 = NULL; | |
1089 | const struct x86_cpu_id *id; | |
1090 | int size, ret = -ENOMEM; | |
1091 | ||
1092 | id = x86_match_cpu(telemetry_cpu_ids); | |
1093 | if (!id) | |
1094 | return -ENODEV; | |
1095 | ||
1096 | telm_conf = (struct telemetry_plt_config *)id->driver_data; | |
1097 | ||
1098 | res0 = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
1099 | if (!res0) { | |
1100 | ret = -EINVAL; | |
1101 | goto out; | |
1102 | } | |
1103 | size = resource_size(res0); | |
1104 | if (!devm_request_mem_region(&pdev->dev, res0->start, size, | |
1105 | pdev->name)) { | |
1106 | ret = -EBUSY; | |
1107 | goto out; | |
1108 | } | |
1109 | telm_conf->pss_config.ssram_base_addr = res0->start; | |
1110 | telm_conf->pss_config.ssram_size = size; | |
1111 | ||
1112 | res1 = platform_get_resource(pdev, IORESOURCE_MEM, 1); | |
1113 | if (!res1) { | |
1114 | ret = -EINVAL; | |
1115 | goto out; | |
1116 | } | |
1117 | size = resource_size(res1); | |
1118 | if (!devm_request_mem_region(&pdev->dev, res1->start, size, | |
1119 | pdev->name)) { | |
1120 | ret = -EBUSY; | |
1121 | goto out; | |
1122 | } | |
1123 | ||
1124 | telm_conf->ioss_config.ssram_base_addr = res1->start; | |
1125 | telm_conf->ioss_config.ssram_size = size; | |
1126 | ||
1127 | telm_conf->pss_config.regmap = ioremap_nocache( | |
1128 | telm_conf->pss_config.ssram_base_addr, | |
1129 | telm_conf->pss_config.ssram_size); | |
1130 | if (!telm_conf->pss_config.regmap) { | |
1131 | ret = -ENOMEM; | |
1132 | goto out; | |
1133 | } | |
1134 | ||
1135 | telm_conf->ioss_config.regmap = ioremap_nocache( | |
1136 | telm_conf->ioss_config.ssram_base_addr, | |
1137 | telm_conf->ioss_config.ssram_size); | |
1138 | if (!telm_conf->ioss_config.regmap) { | |
1139 | ret = -ENOMEM; | |
1140 | goto out; | |
1141 | } | |
1142 | ||
1143 | mutex_init(&telm_conf->telem_lock); | |
1144 | mutex_init(&telm_conf->telem_trace_lock); | |
1145 | ||
1146 | ret = telemetry_setup(pdev); | |
1147 | if (ret) | |
1148 | goto out; | |
1149 | ||
1150 | ret = telemetry_set_pltdata(&telm_pltops, telm_conf); | |
1151 | if (ret) { | |
1152 | dev_err(&pdev->dev, "TELEMTRY Set Pltops Failed.\n"); | |
1153 | goto out; | |
1154 | } | |
1155 | ||
1156 | return 0; | |
1157 | ||
1158 | out: | |
1159 | if (res0) | |
1160 | release_mem_region(res0->start, resource_size(res0)); | |
1161 | if (res1) | |
1162 | release_mem_region(res1->start, resource_size(res1)); | |
1163 | if (telm_conf->pss_config.regmap) | |
1164 | iounmap(telm_conf->pss_config.regmap); | |
1165 | if (telm_conf->ioss_config.regmap) | |
1166 | iounmap(telm_conf->ioss_config.regmap); | |
1167 | dev_err(&pdev->dev, "TELEMTRY Setup Failed.\n"); | |
1168 | ||
1169 | return ret; | |
1170 | } | |
1171 | ||
1172 | static int telemetry_pltdrv_remove(struct platform_device *pdev) | |
1173 | { | |
1174 | telemetry_clear_pltdata(); | |
1175 | iounmap(telm_conf->pss_config.regmap); | |
1176 | iounmap(telm_conf->ioss_config.regmap); | |
1177 | ||
1178 | return 0; | |
1179 | } | |
1180 | ||
1181 | static struct platform_driver telemetry_soc_driver = { | |
1182 | .probe = telemetry_pltdrv_probe, | |
1183 | .remove = telemetry_pltdrv_remove, | |
1184 | .driver = { | |
1185 | .name = DRIVER_NAME, | |
1186 | }, | |
1187 | }; | |
1188 | ||
1189 | static int __init telemetry_module_init(void) | |
1190 | { | |
1191 | pr_info(DRIVER_NAME ": version %s loaded\n", DRIVER_VERSION); | |
1192 | return platform_driver_register(&telemetry_soc_driver); | |
1193 | } | |
1194 | ||
1195 | static void __exit telemetry_module_exit(void) | |
1196 | { | |
1197 | platform_driver_unregister(&telemetry_soc_driver); | |
1198 | } | |
1199 | ||
1200 | device_initcall(telemetry_module_init); | |
1201 | module_exit(telemetry_module_exit); | |
1202 | ||
1203 | MODULE_AUTHOR("Souvik Kumar Chakravarty <souvik.k.chakravarty@intel.com>"); | |
1204 | MODULE_DESCRIPTION("Intel SoC Telemetry Platform Driver"); | |
1205 | MODULE_VERSION(DRIVER_VERSION); | |
1206 | MODULE_LICENSE("GPL"); |