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