?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mmc: rtsx_pci: Enable MMC_CAP_ERASE to allow erase/discard/trim requests
[linux/fpc-iii.git] / drivers / platform / x86 / intel_telemetry_pltdrv.c
blob09c84a2b1c2cef7ecbeaf19795dfdd2048c5c66e
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 = 0;
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_READ_TELE_TRACE_CTRL,
1034 0, 0, NULL, &temp);
1035 if (ret) {
1036 pr_err("PSS TRACE_CTRL Read Failed\n");
1037 goto out;
1038 }
1039
1040 TELEM_CLEAR_VERBOSITY_BITS(temp);
1041 TELEM_SET_VERBOSITY_BITS(temp, verbosity);
1042
1043 ret = intel_punit_ipc_command(
1044 IPC_PUNIT_BIOS_WRITE_TELE_TRACE_CTRL,
1045 0, 0, &temp, NULL);
1046 if (ret) {
1047 pr_err("PSS TRACE_CTRL Verbosity Set Failed\n");
1048 goto out;
1049 }
1050 break;
1051
1052 case TELEM_IOSS:
1053 ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY,
1054 IOSS_TELEM_TRACE_CTL_READ, NULL, 0, &temp,
1055 IOSS_TELEM_READ_WORD);
1056 if (ret) {
1057 pr_err("IOSS TRACE_CTL Read Failed\n");
1058 goto out;
1059 }
1060
1061 TELEM_CLEAR_VERBOSITY_BITS(temp);
1062 TELEM_SET_VERBOSITY_BITS(temp, verbosity);
1063
1064 ret = intel_pmc_ipc_command(PMC_IPC_PMC_TELEMTRY,
1065 IOSS_TELEM_TRACE_CTL_WRITE, (u8 *)&temp,
1066 IOSS_TELEM_WRITE_FOURBYTES, NULL, 0);
1067 if (ret) {
1068 pr_err("IOSS TRACE_CTL Verbosity Set Failed\n");
1069 goto out;
1070 }
1071 break;
1072
1073 default:
1074 pr_err("Unknown Telemetry Unit Specified %d\n", telem_unit);
1075 ret = -EINVAL;
1076 break;
1077 }
1078
1079 out:
1080 mutex_unlock(&(telm_conf->telem_trace_lock));
1081 return ret;
1082 }
1083
1084 static const struct telemetry_core_ops telm_pltops = {
1085 .get_trace_verbosity = telemetry_plt_get_trace_verbosity,
1086 .set_trace_verbosity = telemetry_plt_set_trace_verbosity,
1087 .set_sampling_period = telemetry_plt_set_sampling_period,
1088 .get_sampling_period = telemetry_plt_get_sampling_period,
1089 .raw_read_eventlog = telemetry_plt_raw_read_eventlog,
1090 .get_eventconfig = telemetry_plt_get_eventconfig,
1091 .update_events = telemetry_plt_update_events,
1092 .read_eventlog = telemetry_plt_read_eventlog,
1093 .reset_events = telemetry_plt_reset_events,
1094 .add_events = telemetry_plt_add_events,
1095 };
1096
1097 static int telemetry_pltdrv_probe(struct platform_device *pdev)
1098 {
1099 struct resource *res0 = NULL, *res1 = NULL;
1100 const struct x86_cpu_id *id;
1101 int size, ret = -ENOMEM;
1102
1103 id = x86_match_cpu(telemetry_cpu_ids);
1104 if (!id)
1105 return -ENODEV;
1106
1107 telm_conf = (struct telemetry_plt_config *)id->driver_data;
1108
1109 res0 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1110 if (!res0) {
1111 ret = -EINVAL;
1112 goto out;
1113 }
1114 size = resource_size(res0);
1115 if (!devm_request_mem_region(&pdev->dev, res0->start, size,
1116 pdev->name)) {
1117 ret = -EBUSY;
1118 goto out;
1119 }
1120 telm_conf->pss_config.ssram_base_addr = res0->start;
1121 telm_conf->pss_config.ssram_size = size;
1122
1123 res1 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1124 if (!res1) {
1125 ret = -EINVAL;
1126 goto out;
1127 }
1128 size = resource_size(res1);
1129 if (!devm_request_mem_region(&pdev->dev, res1->start, size,
1130 pdev->name)) {
1131 ret = -EBUSY;
1132 goto out;
1133 }
1134
1135 telm_conf->ioss_config.ssram_base_addr = res1->start;
1136 telm_conf->ioss_config.ssram_size = size;
1137
1138 telm_conf->pss_config.regmap = ioremap_nocache(
1139 telm_conf->pss_config.ssram_base_addr,
1140 telm_conf->pss_config.ssram_size);
1141 if (!telm_conf->pss_config.regmap) {
1142 ret = -ENOMEM;
1143 goto out;
1144 }
1145
1146 telm_conf->ioss_config.regmap = ioremap_nocache(
1147 telm_conf->ioss_config.ssram_base_addr,
1148 telm_conf->ioss_config.ssram_size);
1149 if (!telm_conf->ioss_config.regmap) {
1150 ret = -ENOMEM;
1151 goto out;
1152 }
1153
1154 mutex_init(&telm_conf->telem_lock);
1155 mutex_init(&telm_conf->telem_trace_lock);
1156
1157 ret = telemetry_setup(pdev);
1158 if (ret)
1159 goto out;
1160
1161 ret = telemetry_set_pltdata(&telm_pltops, telm_conf);
1162 if (ret) {
1163 dev_err(&pdev->dev, "TELEMTRY Set Pltops Failed.\n");
1164 goto out;
1165 }
1166
1167 return 0;
1168
1169 out:
1170 if (res0)
1171 release_mem_region(res0->start, resource_size(res0));
1172 if (res1)
1173 release_mem_region(res1->start, resource_size(res1));
1174 if (telm_conf->pss_config.regmap)
1175 iounmap(telm_conf->pss_config.regmap);
1176 if (telm_conf->ioss_config.regmap)
1177 iounmap(telm_conf->ioss_config.regmap);
1178 dev_err(&pdev->dev, "TELEMTRY Setup Failed.\n");
1179
1180 return ret;
1181 }
1182
1183 static int telemetry_pltdrv_remove(struct platform_device *pdev)
1184 {
1185 telemetry_clear_pltdata();
1186 iounmap(telm_conf->pss_config.regmap);
1187 iounmap(telm_conf->ioss_config.regmap);
1188
1189 return 0;
1190 }
1191
1192 static struct platform_driver telemetry_soc_driver = {
1193 .probe = telemetry_pltdrv_probe,
1194 .remove = telemetry_pltdrv_remove,
1195 .driver = {
1196 .name = DRIVER_NAME,
1197 },
1198 };
1199
1200 static int __init telemetry_module_init(void)
1201 {
1202 pr_info(DRIVER_NAME ": version %s loaded\n", DRIVER_VERSION);
1203 return platform_driver_register(&telemetry_soc_driver);
1204 }
1205
1206 static void __exit telemetry_module_exit(void)
1207 {
1208 platform_driver_unregister(&telemetry_soc_driver);
1209 }
1210
1211 device_initcall(telemetry_module_init);
1212 module_exit(telemetry_module_exit);
1213
1214 MODULE_AUTHOR("Souvik Kumar Chakravarty <souvik.k.chakravarty@intel.com>");
1215 MODULE_DESCRIPTION("Intel SoC Telemetry Platform Driver");
1216 MODULE_VERSION(DRIVER_VERSION);
1217 MODULE_LICENSE("GPL");
Linux with added FPC-III support