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