drivers/platform/x86/intel_telemetry_pltdrv.c

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