tools/power/x86/intel-speed-select/isst-core-tpmi.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Intel Speed Select -- Enumerate and control features for TPMI Interface
   4  * Copyright (c) 2022 Intel Corporation.
   5  */
   6
   7 #include <linux/isst_if.h>
   8 #include "isst.h"
   9
  10 int tpmi_process_ioctl(int ioctl_no, void *info)
  11 {
  12         const char *pathname = "/dev/isst_interface";
  13         int fd;
  14
  15         if (is_debug_enabled()) {
  16                 debug_printf("Issue IOCTL: ");
  17                 switch (ioctl_no) {
  18                 case ISST_IF_CORE_POWER_STATE:
  19                         debug_printf("ISST_IF_CORE_POWER_STATE\n");
  20                         break;
  21                 case ISST_IF_CLOS_PARAM:
  22                         debug_printf("ISST_IF_CLOS_PARAM\n");
  23                         break;
  24                 case ISST_IF_CLOS_ASSOC:
  25                         debug_printf("ISST_IF_CLOS_ASSOC\n");
  26                         break;
  27                 case ISST_IF_PERF_LEVELS:
  28                         debug_printf("ISST_IF_PERF_LEVELS\n");
  29                         break;
  30                 case ISST_IF_PERF_SET_LEVEL:
  31                         debug_printf("ISST_IF_PERF_SET_LEVEL\n");
  32                         break;
  33                 case ISST_IF_PERF_SET_FEATURE:
  34                         debug_printf("ISST_IF_PERF_SET_FEATURE\n");
  35                         break;
  36                 case ISST_IF_GET_PERF_LEVEL_INFO:
  37                         debug_printf("ISST_IF_GET_PERF_LEVEL_INFO\n");
  38                         break;
  39                 case ISST_IF_GET_PERF_LEVEL_CPU_MASK:
  40                         debug_printf("ISST_IF_GET_PERF_LEVEL_CPU_MASK\n");
  41                         break;
  42                 case ISST_IF_GET_BASE_FREQ_INFO:
  43                         debug_printf("ISST_IF_GET_BASE_FREQ_INFO\n");
  44                         break;
  45                 case ISST_IF_GET_BASE_FREQ_CPU_MASK:
  46                         debug_printf("ISST_IF_GET_BASE_FREQ_CPU_MASK\n");
  47                         break;
  48                 case ISST_IF_GET_TURBO_FREQ_INFO:
  49                         debug_printf("ISST_IF_GET_TURBO_FREQ_INFO\n");
  50                         break;
  51                 case ISST_IF_COUNT_TPMI_INSTANCES:
  52                         debug_printf("ISST_IF_COUNT_TPMI_INSTANCES\n");
  53                         break;
  54                 default:
  55                         debug_printf("%d\n", ioctl_no);
  56                         break;
  57                 }
  58         }
  59
  60         fd = open(pathname, O_RDWR);
  61         if (fd < 0)
  62                 return -1;
  63
  64         if (ioctl(fd, ioctl_no, info) == -1) {
  65                 debug_printf("IOCTL %d Failed\n", ioctl_no);
  66                 close(fd);
  67                 return -1;
  68         }
  69
  70         close(fd);
  71
  72         return 0;
  73 }
  74
  75 static int tpmi_get_disp_freq_multiplier(void)
  76 {
  77         return 1;
  78 }
  79
  80 static int tpmi_get_trl_max_levels(void)
  81 {
  82         return TRL_MAX_LEVELS;
  83 }
  84
  85 static char *tpmi_get_trl_level_name(int level)
  86 {
  87         switch (level) {
  88         case 0:
  89                 return "level-0";
  90         case 1:
  91                 return "level-1";
  92         case 2:
  93                 return "level-2";
  94         case 3:
  95                 return "level-3";
  96         case 4:
  97                 return "level-4";
  98         case 5:
  99                 return "level-5";
 100         case 6:
 101                 return "level-6";
 102         case 7:
 103                 return "level-7";
 104         default:
 105                 return NULL;
 106         }
 107 }
 108
 109
 110 static void tpmi_update_platform_param(enum isst_platform_param param, int value)
 111 {
 112         /* No params need to be updated for now */
 113 }
 114
 115 static int tpmi_is_punit_valid(struct isst_id *id)
 116 {
 117         struct isst_tpmi_instance_count info;
 118         int ret;
 119
 120         if (id->punit < 0)
 121                 return 0;
 122
 123         info.socket_id = id->pkg;
 124         ret = tpmi_process_ioctl(ISST_IF_COUNT_TPMI_INSTANCES, &info);
 125         if (ret == -1)
 126                 return 0;
 127
 128         if (info.valid_mask & BIT(id->punit))
 129                 return 1;
 130
 131         return 0;
 132 }
 133
 134 static int tpmi_read_pm_config(struct isst_id *id, int *cp_state, int *cp_cap)
 135 {
 136         struct isst_core_power info;
 137         int ret;
 138
 139         info.get_set = 0;
 140         info.socket_id = id->pkg;
 141         info.power_domain_id = id->punit;
 142         ret = tpmi_process_ioctl(ISST_IF_CORE_POWER_STATE, &info);
 143         if (ret == -1)
 144                 return ret;
 145
 146         *cp_state = info.enable;
 147         *cp_cap = info.supported;
 148
 149         return 0;
 150 }
 151
 152 int tpmi_get_config_levels(struct isst_id *id, struct isst_pkg_ctdp *pkg_dev)
 153 {
 154         struct isst_perf_level_info info;
 155         int ret;
 156
 157         info.socket_id = id->pkg;
 158         info.power_domain_id = id->punit;
 159
 160         ret = tpmi_process_ioctl(ISST_IF_PERF_LEVELS, &info);
 161         if (ret == -1)
 162                 return ret;
 163
 164         pkg_dev->version = info.feature_rev;
 165         pkg_dev->levels = info.max_level;
 166         pkg_dev->locked = info.locked;
 167         pkg_dev->current_level = info.current_level;
 168         pkg_dev->locked = info.locked;
 169         pkg_dev->enabled = info.enabled;
 170
 171         return 0;
 172 }
 173
 174 static int tpmi_get_ctdp_control(struct isst_id *id, int config_index,
 175                                  struct isst_pkg_ctdp_level_info *ctdp_level)
 176 {
 177         struct isst_core_power core_power_info;
 178         struct isst_perf_level_info info;
 179         int level_mask;
 180         int ret;
 181
 182         info.socket_id = id->pkg;
 183         info.power_domain_id = id->punit;
 184
 185         ret = tpmi_process_ioctl(ISST_IF_PERF_LEVELS, &info);
 186         if (ret == -1)
 187                 return -1;
 188
 189         if (config_index != 0xff)
 190                 level_mask = 1 << config_index;
 191         else
 192                 level_mask = config_index;
 193
 194         if (!(info.level_mask & level_mask))
 195                 return -1;
 196
 197         ctdp_level->fact_support = info.sst_tf_support;
 198         ctdp_level->pbf_support = info.sst_bf_support;
 199         ctdp_level->fact_enabled = !!(info.feature_state & BIT(1));
 200         ctdp_level->pbf_enabled = !!(info.feature_state & BIT(0));
 201
 202         core_power_info.get_set = 0;
 203         core_power_info.socket_id = id->pkg;
 204         core_power_info.power_domain_id = id->punit;
 205
 206         ret = tpmi_process_ioctl(ISST_IF_CORE_POWER_STATE, &core_power_info);
 207         if (ret == -1)
 208                 return ret;
 209
 210         ctdp_level->sst_cp_support = core_power_info.supported;
 211         ctdp_level->sst_cp_enabled = core_power_info.enable;
 212
 213         debug_printf
 214             ("cpu:%d CONFIG_TDP_GET_TDP_CONTROL fact_support:%d pbf_support: %d fact_enabled:%d pbf_enabled:%d\n",
 215              id->cpu, ctdp_level->fact_support, ctdp_level->pbf_support,
 216              ctdp_level->fact_enabled, ctdp_level->pbf_enabled);
 217
 218         return 0;
 219 }
 220
 221 static int tpmi_get_tdp_info(struct isst_id *id, int config_index,
 222                              struct isst_pkg_ctdp_level_info *ctdp_level)
 223 {
 224         struct isst_perf_level_data_info info;
 225         int ret;
 226
 227         info.socket_id = id->pkg;
 228         info.power_domain_id = id->punit;
 229         info.level = config_index;
 230
 231         ret = tpmi_process_ioctl(ISST_IF_GET_PERF_LEVEL_INFO, &info);
 232         if (ret == -1)
 233                 return ret;
 234
 235         ctdp_level->pkg_tdp = info.thermal_design_power_w;
 236         ctdp_level->tdp_ratio = info.tdp_ratio;
 237         ctdp_level->sse_p1 = info.base_freq_mhz;
 238         ctdp_level->avx2_p1 = info.base_freq_avx2_mhz;
 239         ctdp_level->avx512_p1 = info.base_freq_avx512_mhz;
 240         ctdp_level->amx_p1 = info.base_freq_amx_mhz;
 241
 242         ctdp_level->t_proc_hot = info.tjunction_max_c;
 243         ctdp_level->mem_freq = info.max_memory_freq_mhz;
 244         ctdp_level->cooling_type = info.cooling_type;
 245
 246         ctdp_level->uncore_p0 = info.p0_fabric_freq_mhz;
 247         ctdp_level->uncore_p1 = info.p1_fabric_freq_mhz;
 248         ctdp_level->uncore_pm = info.pm_fabric_freq_mhz;
 249
 250         debug_printf
 251             ("cpu:%d ctdp:%d CONFIG_TDP_GET_TDP_INFO tdp_ratio:%d pkg_tdp:%d ctdp_level->t_proc_hot:%d\n",
 252              id->cpu, config_index, ctdp_level->tdp_ratio, ctdp_level->pkg_tdp,
 253              ctdp_level->t_proc_hot);
 254
 255         return 0;
 256 }
 257
 258 static int tpmi_get_pwr_info(struct isst_id *id, int config_index,
 259                              struct isst_pkg_ctdp_level_info *ctdp_level)
 260 {
 261         /* TBD */
 262         ctdp_level->pkg_max_power = 0;
 263         ctdp_level->pkg_min_power = 0;
 264
 265         debug_printf
 266             ("cpu:%d ctdp:%d CONFIG_TDP_GET_PWR_INFO pkg_max_power:%d pkg_min_power:%d\n",
 267              id->cpu, config_index, ctdp_level->pkg_max_power,
 268              ctdp_level->pkg_min_power);
 269
 270         return 0;
 271 }
 272
 273 int tpmi_get_coremask_info(struct isst_id *id, int config_index,
 274                            struct isst_pkg_ctdp_level_info *ctdp_level)
 275 {
 276         struct isst_perf_level_cpu_mask info;
 277         int ret, cpu_count;
 278
 279         info.socket_id = id->pkg;
 280         info.power_domain_id = id->punit;
 281         info.level = config_index;
 282         info.punit_cpu_map = 1;
 283
 284         ret = tpmi_process_ioctl(ISST_IF_GET_PERF_LEVEL_CPU_MASK, &info);
 285         if (ret == -1)
 286                 return ret;
 287
 288         set_cpu_mask_from_punit_coremask(id, info.mask,
 289                                          ctdp_level->core_cpumask_size,
 290                                          ctdp_level->core_cpumask, &cpu_count);
 291         ctdp_level->cpu_count = cpu_count;
 292
 293         debug_printf("cpu:%d ctdp:%d core_mask ino cpu count:%d\n",
 294                      id->cpu, config_index, ctdp_level->cpu_count);
 295
 296         return 0;
 297 }
 298
 299 static int tpmi_get_get_trls(struct isst_id *id, int config_index,
 300                              struct isst_pkg_ctdp_level_info *ctdp_level)
 301 {
 302         struct isst_perf_level_data_info info;
 303         int ret, i, j;
 304
 305         info.socket_id = id->pkg;
 306         info.power_domain_id = id->punit;
 307         info.level = config_index;
 308
 309         ret = tpmi_process_ioctl(ISST_IF_GET_PERF_LEVEL_INFO, &info);
 310         if (ret == -1)
 311                 return ret;
 312
 313         if (info.max_buckets > TRL_MAX_BUCKETS)
 314                 info.max_buckets = TRL_MAX_BUCKETS;
 315
 316         if (info.max_trl_levels > TRL_MAX_LEVELS)
 317                 info.max_trl_levels = TRL_MAX_LEVELS;
 318
 319         for (i = 0; i < info.max_trl_levels; ++i)
 320                 for (j = 0; j < info.max_buckets; ++j)
 321                         ctdp_level->trl_ratios[i][j] = info.trl_freq_mhz[i][j];
 322
 323         return 0;
 324 }
 325
 326 static int tpmi_get_get_trl(struct isst_id *id, int level, int config_index,
 327                             int *trl)
 328 {
 329         struct isst_pkg_ctdp_level_info ctdp_level;
 330         int ret, i;
 331
 332         ret = tpmi_get_get_trls(id, config_index, &ctdp_level);
 333         if (ret)
 334                 return ret;
 335
 336         /* FIX ME: Just return for level 0 */
 337         for (i = 0; i < 8; ++i)
 338                 trl[i] = ctdp_level.trl_ratios[0][i];
 339
 340         return 0;
 341 }
 342
 343 static int tpmi_get_trl_bucket_info(struct isst_id *id, int config_index,
 344                                     unsigned long long *buckets_info)
 345 {
 346         struct isst_perf_level_data_info info;
 347         unsigned char *mask = (unsigned char *)buckets_info;
 348         int ret, i;
 349
 350         info.socket_id = id->pkg;
 351         info.power_domain_id = id->punit;
 352         info.level = config_index;
 353
 354         ret = tpmi_process_ioctl(ISST_IF_GET_PERF_LEVEL_INFO, &info);
 355         if (ret == -1)
 356                 return ret;
 357
 358         if (info.max_buckets > TRL_MAX_BUCKETS)
 359                 info.max_buckets = TRL_MAX_BUCKETS;
 360
 361         for (i = 0; i < info.max_buckets; ++i)
 362                 mask[i] = info.bucket_core_counts[i];
 363
 364         debug_printf("cpu:%d TRL bucket info: 0x%llx\n", id->cpu,
 365                      *buckets_info);
 366
 367         return 0;
 368 }
 369
 370 static int tpmi_set_tdp_level(struct isst_id *id, int tdp_level)
 371 {
 372         struct isst_perf_level_control info;
 373         int ret;
 374
 375         info.socket_id = id->pkg;
 376         info.power_domain_id = id->punit;
 377         info.level = tdp_level;
 378
 379         ret = tpmi_process_ioctl(ISST_IF_PERF_SET_LEVEL, &info);
 380         if (ret == -1)
 381                 return ret;
 382
 383         return 0;
 384 }
 385
 386 static int _pbf_get_coremask_info(struct isst_id *id, int config_index,
 387                                   struct isst_pbf_info *pbf_info)
 388 {
 389         struct isst_perf_level_cpu_mask info;
 390         int ret, cpu_count;
 391
 392         info.socket_id = id->pkg;
 393         info.power_domain_id = id->punit;
 394         info.level = config_index;
 395         info.punit_cpu_map = 1;
 396
 397         ret = tpmi_process_ioctl(ISST_IF_GET_BASE_FREQ_CPU_MASK, &info);
 398         if (ret == -1)
 399                 return ret;
 400
 401         set_cpu_mask_from_punit_coremask(id, info.mask,
 402                                          pbf_info->core_cpumask_size,
 403                                          pbf_info->core_cpumask, &cpu_count);
 404
 405         debug_printf("cpu:%d ctdp:%d pbf core_mask info cpu count:%d\n",
 406                      id->cpu, config_index, cpu_count);
 407
 408         return 0;
 409 }
 410
 411 static int tpmi_get_pbf_info(struct isst_id *id, int level,
 412                              struct isst_pbf_info *pbf_info)
 413 {
 414         struct isst_base_freq_info info;
 415         int ret;
 416
 417         info.socket_id = id->pkg;
 418         info.power_domain_id = id->punit;
 419         info.level = level;
 420
 421         ret = tpmi_process_ioctl(ISST_IF_GET_BASE_FREQ_INFO, &info);
 422         if (ret == -1)
 423                 return ret;
 424
 425         pbf_info->p1_low = info.low_base_freq_mhz;
 426         pbf_info->p1_high = info.high_base_freq_mhz;
 427         pbf_info->tdp = info.thermal_design_power_w;
 428         pbf_info->t_prochot = info.tjunction_max_c;
 429
 430         debug_printf("cpu:%d ctdp:%d pbf info:%d:%d:%d:%d\n",
 431                      id->cpu, level, pbf_info->p1_low, pbf_info->p1_high,
 432                      pbf_info->tdp, pbf_info->t_prochot);
 433
 434         return _pbf_get_coremask_info(id, level, pbf_info);
 435 }
 436
 437 static int tpmi_set_pbf_fact_status(struct isst_id *id, int pbf, int enable)
 438 {
 439         struct isst_pkg_ctdp pkg_dev;
 440         struct isst_pkg_ctdp_level_info ctdp_level;
 441         int current_level;
 442         struct isst_perf_feature_control info;
 443         int ret;
 444
 445         ret = isst_get_ctdp_levels(id, &pkg_dev);
 446         if (ret)
 447                 debug_printf("cpu:%d No support for dynamic ISST\n", id->cpu);
 448
 449         current_level = pkg_dev.current_level;
 450
 451         ret = isst_get_ctdp_control(id, current_level, &ctdp_level);
 452         if (ret)
 453                 return ret;
 454
 455         info.socket_id = id->pkg;
 456         info.power_domain_id = id->punit;
 457
 458         info.feature = 0;
 459
 460         if (pbf) {
 461                 if (ctdp_level.fact_enabled)
 462                         info.feature |= BIT(1);
 463
 464                 if (enable)
 465                         info.feature |= BIT(0);
 466                 else
 467                         info.feature &= ~BIT(0);
 468         } else {
 469
 470                 if (enable && !ctdp_level.sst_cp_enabled)
 471                         isst_display_error_info_message(0,
 472                                                         "Make sure to execute before: core-power enable",
 473                                                         0, 0);
 474
 475                 if (ctdp_level.pbf_enabled)
 476                         info.feature |= BIT(0);
 477
 478                 if (enable)
 479                         info.feature |= BIT(1);
 480                 else
 481                         info.feature &= ~BIT(1);
 482         }
 483
 484         ret = tpmi_process_ioctl(ISST_IF_PERF_SET_FEATURE, &info);
 485         if (ret == -1)
 486                 return ret;
 487
 488         return 0;
 489 }
 490
 491 static int tpmi_get_fact_info(struct isst_id *id, int level, int fact_bucket,
 492                               struct isst_fact_info *fact_info)
 493 {
 494         struct isst_turbo_freq_info info;
 495         int i, j;
 496         int ret;
 497
 498         info.socket_id = id->pkg;
 499         info.power_domain_id = id->punit;
 500         info.level = level;
 501
 502         ret = tpmi_process_ioctl(ISST_IF_GET_TURBO_FREQ_INFO, &info);
 503         if (ret == -1)
 504                 return ret;
 505
 506         for (i = 0; i < info.max_clip_freqs; ++i)
 507                 fact_info->lp_ratios[i] = info.lp_clip_freq_mhz[i];
 508
 509         if (info.max_buckets > TRL_MAX_BUCKETS)
 510                 info.max_buckets = TRL_MAX_BUCKETS;
 511
 512         if (info.max_trl_levels > TRL_MAX_LEVELS)
 513                 info.max_trl_levels = TRL_MAX_LEVELS;
 514
 515         for (i = 0; i < info.max_trl_levels; ++i) {
 516                 for (j = 0; j < info.max_buckets; ++j)
 517                         fact_info->bucket_info[j].hp_ratios[i] =
 518                             info.trl_freq_mhz[i][j];
 519         }
 520
 521         for (i = 0; i < info.max_buckets; ++i)
 522                 fact_info->bucket_info[i].hp_cores = info.bucket_core_counts[i];
 523
 524         return 0;
 525 }
 526
 527 static void _set_uncore_min_max(struct isst_id *id, int max, int freq)
 528 {
 529         DIR *dir;
 530         FILE *filep;
 531         struct dirent *entry;
 532         char buffer[512];
 533         unsigned int tmp_id;
 534         int ret;
 535
 536         dir = opendir("/sys/devices/system/cpu/intel_uncore_frequency/");
 537         if (!dir)
 538                 return;
 539
 540         while ((entry = readdir(dir)) != NULL ) {
 541                 /* Check domain_id */
 542                 snprintf(buffer, sizeof(buffer),
 543                          "/sys/devices/system/cpu/intel_uncore_frequency/%s/domain_id", entry->d_name);
 544
 545                 filep = fopen(buffer, "r");
 546                 if (!filep)
 547                         goto end;
 548
 549                 ret = fscanf(filep, "%u", &tmp_id);
 550                 fclose(filep);
 551                 if (ret != 1)
 552                         goto end;
 553
 554                 if (tmp_id != id->punit)
 555                         continue;
 556
 557                 /* Check package_id */
 558                 snprintf(buffer, sizeof(buffer),
 559                          "/sys/devices/system/cpu/intel_uncore_frequency/%s/package_id", entry->d_name);
 560
 561                 filep = fopen(buffer, "r");
 562                 if (!filep)
 563                         goto end;
 564
 565                 ret = fscanf(filep, "%u", &tmp_id);
 566                 fclose(filep);
 567
 568                 if (ret != 1)
 569                         goto end;
 570
 571                 if (tmp_id != id->pkg)
 572                         continue;
 573
 574                 /* Found the right sysfs path, adjust and quit */
 575                 if (max)
 576                         snprintf(buffer, sizeof(buffer),
 577                                  "/sys/devices/system/cpu/intel_uncore_frequency/%s/max_freq_khz", entry->d_name);
 578                  else
 579                         snprintf(buffer, sizeof(buffer),
 580                                  "/sys/devices/system/cpu/intel_uncore_frequency/%s/min_freq_khz", entry->d_name);
 581
 582                 filep = fopen(buffer, "w");
 583                 if (!filep)
 584                         goto end;
 585
 586                 fprintf(filep, "%d\n", freq);
 587                 fclose(filep);
 588                 break;
 589         }
 590
 591 end:
 592         closedir(dir);
 593 }
 594
 595 static void tpmi_adjust_uncore_freq(struct isst_id *id, int config_index,
 596                                 struct isst_pkg_ctdp_level_info *ctdp_level)
 597 {
 598         struct isst_perf_level_data_info info;
 599         int ret;
 600
 601         info.socket_id = id->pkg;
 602         info.power_domain_id = id->punit;
 603         info.level = config_index;
 604
 605         ret = tpmi_process_ioctl(ISST_IF_GET_PERF_LEVEL_INFO, &info);
 606         if (ret == -1)
 607                 return;
 608
 609         ctdp_level->uncore_p0 = info.p0_fabric_freq_mhz;
 610         ctdp_level->uncore_p1 = info.p1_fabric_freq_mhz;
 611         ctdp_level->uncore_pm = info.pm_fabric_freq_mhz;
 612
 613         if (ctdp_level->uncore_pm)
 614                 _set_uncore_min_max(id, 0, ctdp_level->uncore_pm * 100000);
 615
 616         if (ctdp_level->uncore_p0)
 617                 _set_uncore_min_max(id, 1, ctdp_level->uncore_p0 * 100000);
 618
 619         return;
 620 }
 621
 622 static int tpmi_get_clos_information(struct isst_id *id, int *enable, int *type)
 623 {
 624         struct isst_core_power info;
 625         int ret;
 626
 627         info.get_set = 0;
 628         info.socket_id = id->pkg;
 629         info.power_domain_id = id->punit;
 630         ret = tpmi_process_ioctl(ISST_IF_CORE_POWER_STATE, &info);
 631         if (ret == -1)
 632                 return ret;
 633
 634         *enable = info.enable;
 635         *type = info.priority_type;
 636
 637         return 0;
 638 }
 639
 640 static int tpmi_pm_qos_config(struct isst_id *id, int enable_clos,
 641                               int priority_type)
 642 {
 643         struct isst_core_power info;
 644         int i, ret, saved_punit;
 645
 646         info.get_set = 1;
 647         info.socket_id = id->pkg;
 648         info.power_domain_id = id->punit;
 649         info.enable = enable_clos;
 650         info.priority_type = priority_type;
 651
 652         saved_punit = id->punit;
 653
 654         /* Set for all other dies also. This is per package setting */
 655         for (i = 0; i < MAX_PUNIT_PER_DIE; i++) {
 656                 id->punit = i;
 657                 if (isst_is_punit_valid(id)) {
 658                         info.power_domain_id = i;
 659                         ret = tpmi_process_ioctl(ISST_IF_CORE_POWER_STATE, &info);
 660                         if (ret == -1) {
 661                                 id->punit = saved_punit;
 662                                 return ret;
 663                         }
 664                 }
 665         }
 666
 667         id->punit = saved_punit;
 668
 669         return 0;
 670 }
 671
 672 int tpmi_pm_get_clos(struct isst_id *id, int clos,
 673                      struct isst_clos_config *clos_config)
 674 {
 675         struct isst_clos_param info;
 676         int ret;
 677
 678         info.get_set = 0;
 679         info.socket_id = id->pkg;
 680         info.power_domain_id = id->punit;
 681         info.clos = clos;
 682
 683         ret = tpmi_process_ioctl(ISST_IF_CLOS_PARAM, &info);
 684         if (ret == -1)
 685                 return ret;
 686
 687         clos_config->epp = 0;
 688         clos_config->clos_prop_prio = info.prop_prio;
 689         clos_config->clos_min = info.min_freq_mhz;
 690         clos_config->clos_max = info.max_freq_mhz;
 691         clos_config->clos_desired = 0;
 692
 693         debug_printf("cpu:%d clos:%d min:%d max:%d\n", id->cpu, clos,
 694                      clos_config->clos_min, clos_config->clos_max);
 695
 696         return 0;
 697 }
 698
 699 int tpmi_set_clos(struct isst_id *id, int clos,
 700                   struct isst_clos_config *clos_config)
 701 {
 702         struct isst_clos_param info;
 703         int i, ret, saved_punit;
 704
 705         info.get_set = 1;
 706         info.socket_id = id->pkg;
 707         info.power_domain_id = id->punit;
 708         info.clos = clos;
 709         info.prop_prio = clos_config->clos_prop_prio;
 710
 711         info.min_freq_mhz = clos_config->clos_min;
 712         info.max_freq_mhz = clos_config->clos_max;
 713
 714         if (info.min_freq_mhz <= 0xff)
 715                 info.min_freq_mhz *= 100;
 716         if (info.max_freq_mhz <= 0xff)
 717                 info.max_freq_mhz *= 100;
 718
 719         saved_punit = id->punit;
 720
 721         /* Set for all other dies also. This is per package setting */
 722         for (i = 0; i < MAX_PUNIT_PER_DIE; i++) {
 723                 id->punit = i;
 724                 if (isst_is_punit_valid(id)) {
 725                         info.power_domain_id = i;
 726                         ret = tpmi_process_ioctl(ISST_IF_CLOS_PARAM, &info);
 727                         if (ret == -1) {
 728                                 id->punit = saved_punit;
 729                                 return ret;
 730                         }
 731                 }
 732         }
 733
 734         id->punit = saved_punit;
 735
 736         debug_printf("set cpu:%d clos:%d min:%d max:%d\n", id->cpu, clos,
 737                      clos_config->clos_min, clos_config->clos_max);
 738
 739         return 0;
 740 }
 741
 742 static int tpmi_clos_get_assoc_status(struct isst_id *id, int *clos_id)
 743 {
 744         struct isst_if_clos_assoc_cmds assoc_cmds;
 745         int ret;
 746
 747         assoc_cmds.cmd_count = 1;
 748         assoc_cmds.get_set = 0;
 749         assoc_cmds.punit_cpu_map = 1;
 750         assoc_cmds.assoc_info[0].logical_cpu = find_phy_core_num(id->cpu);
 751         assoc_cmds.assoc_info[0].socket_id = id->pkg;
 752         assoc_cmds.assoc_info[0].power_domain_id = id->punit;
 753
 754         ret = tpmi_process_ioctl(ISST_IF_CLOS_ASSOC, &assoc_cmds);
 755         if (ret == -1)
 756                 return ret;
 757
 758         *clos_id = assoc_cmds.assoc_info[0].clos;
 759
 760         return 0;
 761 }
 762
 763 static int tpmi_clos_associate(struct isst_id *id, int clos_id)
 764 {
 765         struct isst_if_clos_assoc_cmds assoc_cmds;
 766         int ret;
 767
 768         assoc_cmds.cmd_count = 1;
 769         assoc_cmds.get_set = 1;
 770         assoc_cmds.punit_cpu_map = 1;
 771         assoc_cmds.assoc_info[0].logical_cpu = find_phy_core_num(id->cpu);
 772         assoc_cmds.assoc_info[0].clos = clos_id;
 773         assoc_cmds.assoc_info[0].socket_id = id->pkg;
 774         assoc_cmds.assoc_info[0].power_domain_id = id->punit;
 775
 776         ret = tpmi_process_ioctl(ISST_IF_CLOS_ASSOC, &assoc_cmds);
 777         if (ret == -1)
 778                 return ret;
 779
 780         return 0;
 781 }
 782
 783 static struct isst_platform_ops tpmi_ops = {
 784         .get_disp_freq_multiplier = tpmi_get_disp_freq_multiplier,
 785         .get_trl_max_levels = tpmi_get_trl_max_levels,
 786         .get_trl_level_name = tpmi_get_trl_level_name,
 787         .update_platform_param = tpmi_update_platform_param,
 788         .is_punit_valid = tpmi_is_punit_valid,
 789         .read_pm_config = tpmi_read_pm_config,
 790         .get_config_levels = tpmi_get_config_levels,
 791         .get_ctdp_control = tpmi_get_ctdp_control,
 792         .get_tdp_info = tpmi_get_tdp_info,
 793         .get_pwr_info = tpmi_get_pwr_info,
 794         .get_coremask_info = tpmi_get_coremask_info,
 795         .get_get_trl = tpmi_get_get_trl,
 796         .get_get_trls = tpmi_get_get_trls,
 797         .get_trl_bucket_info = tpmi_get_trl_bucket_info,
 798         .set_tdp_level = tpmi_set_tdp_level,
 799         .get_pbf_info = tpmi_get_pbf_info,
 800         .set_pbf_fact_status = tpmi_set_pbf_fact_status,
 801         .get_fact_info = tpmi_get_fact_info,
 802         .adjust_uncore_freq = tpmi_adjust_uncore_freq,
 803         .get_clos_information = tpmi_get_clos_information,
 804         .pm_qos_config = tpmi_pm_qos_config,
 805         .pm_get_clos = tpmi_pm_get_clos,
 806         .set_clos = tpmi_set_clos,
 807         .clos_get_assoc_status = tpmi_clos_get_assoc_status,
 808         .clos_associate = tpmi_clos_associate,
 809 };
 810
 811 struct isst_platform_ops *tpmi_get_platform_ops(void)
 812 {
 813         return &tpmi_ops;
 814 }