tools/power/x86/intel-speed-select/isst-display.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Intel dynamic_speed_select -- Enumerate and control features
   4  * Copyright (c) 2019 Intel Corporation.
   5  */
   6
   7 #include "isst.h"
   8
   9 static void printcpulist(int str_len, char *str, int mask_size,
  10                          cpu_set_t *cpu_mask)
  11 {
  12         int i, first, curr_index, index;
  13
  14         if (!CPU_COUNT_S(mask_size, cpu_mask)) {
  15                 snprintf(str, str_len, "none");
  16                 return;
  17         }
  18
  19         curr_index = 0;
  20         first = 1;
  21         for (i = 0; i < get_topo_max_cpus(); ++i) {
  22                 if (!CPU_ISSET_S(i, mask_size, cpu_mask))
  23                         continue;
  24                 if (!first) {
  25                         index = snprintf(&str[curr_index],
  26                                          str_len - curr_index, ",");
  27                         curr_index += index;
  28                 }
  29                 index = snprintf(&str[curr_index], str_len - curr_index, "%d",
  30                                  i);
  31                 curr_index += index;
  32                 first = 0;
  33         }
  34 }
  35
  36 static void printcpumask(int str_len, char *str, int mask_size,
  37                          cpu_set_t *cpu_mask)
  38 {
  39         int i, max_cpus = get_topo_max_cpus();
  40         unsigned int *mask;
  41         int size, index, curr_index;
  42
  43         size = max_cpus / (sizeof(unsigned int) * 8);
  44         if (max_cpus % (sizeof(unsigned int) * 8))
  45                 size++;
  46
  47         mask = calloc(size, sizeof(unsigned int));
  48         if (!mask)
  49                 return;
  50
  51         for (i = 0; i < max_cpus; ++i) {
  52                 int mask_index, bit_index;
  53
  54                 if (!CPU_ISSET_S(i, mask_size, cpu_mask))
  55                         continue;
  56
  57                 mask_index = i / (sizeof(unsigned int) * 8);
  58                 bit_index = i % (sizeof(unsigned int) * 8);
  59                 mask[mask_index] |= BIT(bit_index);
  60         }
  61
  62         curr_index = 0;
  63         for (i = size - 1; i >= 0; --i) {
  64                 index = snprintf(&str[curr_index], str_len - curr_index, "%08x",
  65                                  mask[i]);
  66                 curr_index += index;
  67                 if (i) {
  68                         strncat(&str[curr_index], ",", str_len - curr_index);
  69                         curr_index++;
  70                 }
  71         }
  72
  73         free(mask);
  74 }
  75
  76 static void format_and_print_txt(FILE *outf, int level, char *header,
  77                                  char *value)
  78 {
  79         char *spaces = "  ";
  80         static char delimiters[256];
  81         int i, j = 0;
  82
  83         if (!level)
  84                 return;
  85
  86         if (level == 1) {
  87                 strcpy(delimiters, " ");
  88         } else {
  89                 for (i = 0; i < level - 1; ++i)
  90                         j += snprintf(&delimiters[j], sizeof(delimiters) - j,
  91                                       "%s", spaces);
  92         }
  93
  94         if (header && value) {
  95                 fprintf(outf, "%s", delimiters);
  96                 fprintf(outf, "%s:%s\n", header, value);
  97         } else if (header) {
  98                 fprintf(outf, "%s", delimiters);
  99                 fprintf(outf, "%s\n", header);
 100         }
 101 }
 102
 103 static int last_level;
 104 static void format_and_print(FILE *outf, int level, char *header, char *value)
 105 {
 106         char *spaces = "  ";
 107         static char delimiters[256];
 108         int i;
 109
 110         if (!out_format_is_json()) {
 111                 format_and_print_txt(outf, level, header, value);
 112                 return;
 113         }
 114
 115         if (level == 0) {
 116                 if (header)
 117                         fprintf(outf, "{");
 118                 else
 119                         fprintf(outf, "\n}\n");
 120
 121         } else {
 122                 int j = 0;
 123
 124                 for (i = 0; i < level; ++i)
 125                         j += snprintf(&delimiters[j], sizeof(delimiters) - j,
 126                                       "%s", spaces);
 127
 128                 if (last_level == level)
 129                         fprintf(outf, ",\n");
 130
 131                 if (value) {
 132                         if (last_level != level)
 133                                 fprintf(outf, "\n");
 134
 135                         fprintf(outf, "%s\"%s\": ", delimiters, header);
 136                         fprintf(outf, "\"%s\"", value);
 137                 } else {
 138                         for (i = last_level - 1; i >= level; --i) {
 139                                 int k = 0;
 140
 141                                 for (j = i; j > 0; --j)
 142                                         k += snprintf(&delimiters[k],
 143                                                       sizeof(delimiters) - k,
 144                                                       "%s", spaces);
 145                                 if (i == level && header)
 146                                         fprintf(outf, "\n%s},", delimiters);
 147                                 else
 148                                         fprintf(outf, "\n%s}", delimiters);
 149                         }
 150                         if (abs(last_level - level) < 3)
 151                                 fprintf(outf, "\n");
 152                         if (header)
 153                                 fprintf(outf, "%s\"%s\": {", delimiters,
 154                                         header);
 155                 }
 156         }
 157
 158         last_level = level;
 159 }
 160
 161 static void print_package_info(int cpu, FILE *outf)
 162 {
 163         char header[256];
 164
 165         snprintf(header, sizeof(header), "package-%d",
 166                  get_physical_package_id(cpu));
 167         format_and_print(outf, 1, header, NULL);
 168         snprintf(header, sizeof(header), "die-%d", get_physical_die_id(cpu));
 169         format_and_print(outf, 2, header, NULL);
 170         snprintf(header, sizeof(header), "cpu-%d", cpu);
 171         format_and_print(outf, 3, header, NULL);
 172 }
 173
 174 static void _isst_pbf_display_information(int cpu, FILE *outf, int level,
 175                                           struct isst_pbf_info *pbf_info,
 176                                           int disp_level)
 177 {
 178         char header[256];
 179         char value[256];
 180
 181         snprintf(header, sizeof(header), "speed-select-base-freq");
 182         format_and_print(outf, disp_level, header, NULL);
 183
 184         snprintf(header, sizeof(header), "high-priority-base-frequency(MHz)");
 185         snprintf(value, sizeof(value), "%d",
 186                  pbf_info->p1_high * DISP_FREQ_MULTIPLIER);
 187         format_and_print(outf, disp_level + 1, header, value);
 188
 189         snprintf(header, sizeof(header), "high-priority-cpu-mask");
 190         printcpumask(sizeof(value), value, pbf_info->core_cpumask_size,
 191                      pbf_info->core_cpumask);
 192         format_and_print(outf, disp_level + 1, header, value);
 193
 194         snprintf(header, sizeof(header), "high-priority-cpu-list");
 195         printcpulist(sizeof(value), value,
 196                      pbf_info->core_cpumask_size,
 197                      pbf_info->core_cpumask);
 198         format_and_print(outf, disp_level + 1, header, value);
 199
 200         snprintf(header, sizeof(header), "low-priority-base-frequency(MHz)");
 201         snprintf(value, sizeof(value), "%d",
 202                  pbf_info->p1_low * DISP_FREQ_MULTIPLIER);
 203         format_and_print(outf, disp_level + 1, header, value);
 204
 205         if (is_clx_n_platform())
 206                 return;
 207
 208         snprintf(header, sizeof(header), "tjunction-temperature(C)");
 209         snprintf(value, sizeof(value), "%d", pbf_info->t_prochot);
 210         format_and_print(outf, disp_level + 1, header, value);
 211
 212         snprintf(header, sizeof(header), "thermal-design-power(W)");
 213         snprintf(value, sizeof(value), "%d", pbf_info->tdp);
 214         format_and_print(outf, disp_level + 1, header, value);
 215 }
 216
 217 static void _isst_fact_display_information(int cpu, FILE *outf, int level,
 218                                            int fact_bucket, int fact_avx,
 219                                            struct isst_fact_info *fact_info,
 220                                            int base_level)
 221 {
 222         struct isst_fact_bucket_info *bucket_info = fact_info->bucket_info;
 223         char header[256];
 224         char value[256];
 225         int j;
 226
 227         snprintf(header, sizeof(header), "speed-select-turbo-freq");
 228         format_and_print(outf, base_level, header, NULL);
 229         for (j = 0; j < ISST_FACT_MAX_BUCKETS; ++j) {
 230                 if (fact_bucket != 0xff && fact_bucket != j)
 231                         continue;
 232
 233                 if (!bucket_info[j].high_priority_cores_count)
 234                         break;
 235
 236                 snprintf(header, sizeof(header), "bucket-%d", j);
 237                 format_and_print(outf, base_level + 1, header, NULL);
 238
 239                 snprintf(header, sizeof(header), "high-priority-cores-count");
 240                 snprintf(value, sizeof(value), "%d",
 241                          bucket_info[j].high_priority_cores_count);
 242                 format_and_print(outf, base_level + 2, header, value);
 243
 244                 if (fact_avx & 0x01) {
 245                         snprintf(header, sizeof(header),
 246                                  "high-priority-max-frequency(MHz)");
 247                         snprintf(value, sizeof(value), "%d",
 248                                  bucket_info[j].sse_trl * DISP_FREQ_MULTIPLIER);
 249                         format_and_print(outf, base_level + 2, header, value);
 250                 }
 251
 252                 if (fact_avx & 0x02) {
 253                         snprintf(header, sizeof(header),
 254                                  "high-priority-max-avx2-frequency(MHz)");
 255                         snprintf(value, sizeof(value), "%d",
 256                                  bucket_info[j].avx_trl * DISP_FREQ_MULTIPLIER);
 257                         format_and_print(outf, base_level + 2, header, value);
 258                 }
 259
 260                 if (fact_avx & 0x04) {
 261                         snprintf(header, sizeof(header),
 262                                  "high-priority-max-avx512-frequency(MHz)");
 263                         snprintf(value, sizeof(value), "%d",
 264                                  bucket_info[j].avx512_trl *
 265                                          DISP_FREQ_MULTIPLIER);
 266                         format_and_print(outf, base_level + 2, header, value);
 267                 }
 268         }
 269         snprintf(header, sizeof(header),
 270                  "speed-select-turbo-freq-clip-frequencies");
 271         format_and_print(outf, base_level + 1, header, NULL);
 272         snprintf(header, sizeof(header), "low-priority-max-frequency(MHz)");
 273         snprintf(value, sizeof(value), "%d",
 274                  fact_info->lp_clipping_ratio_license_sse *
 275                          DISP_FREQ_MULTIPLIER);
 276         format_and_print(outf, base_level + 2, header, value);
 277         snprintf(header, sizeof(header),
 278                  "low-priority-max-avx2-frequency(MHz)");
 279         snprintf(value, sizeof(value), "%d",
 280                  fact_info->lp_clipping_ratio_license_avx2 *
 281                          DISP_FREQ_MULTIPLIER);
 282         format_and_print(outf, base_level + 2, header, value);
 283         snprintf(header, sizeof(header),
 284                  "low-priority-max-avx512-frequency(MHz)");
 285         snprintf(value, sizeof(value), "%d",
 286                  fact_info->lp_clipping_ratio_license_avx512 *
 287                          DISP_FREQ_MULTIPLIER);
 288         format_and_print(outf, base_level + 2, header, value);
 289 }
 290
 291 void isst_ctdp_display_core_info(int cpu, FILE *outf, char *prefix,
 292                                  unsigned int val)
 293 {
 294         char header[256];
 295         char value[256];
 296
 297         snprintf(header, sizeof(header), "package-%d",
 298                  get_physical_package_id(cpu));
 299         format_and_print(outf, 1, header, NULL);
 300         snprintf(header, sizeof(header), "die-%d", get_physical_die_id(cpu));
 301         format_and_print(outf, 2, header, NULL);
 302         snprintf(header, sizeof(header), "cpu-%d", cpu);
 303         format_and_print(outf, 3, header, NULL);
 304
 305         snprintf(value, sizeof(value), "%u", val);
 306         format_and_print(outf, 4, prefix, value);
 307
 308         format_and_print(outf, 1, NULL, NULL);
 309 }
 310
 311 void isst_ctdp_display_information(int cpu, FILE *outf, int tdp_level,
 312                                    struct isst_pkg_ctdp *pkg_dev)
 313 {
 314         char header[256];
 315         char value[256];
 316         int i, base_level = 1;
 317
 318         if (pkg_dev->processed)
 319                 print_package_info(cpu, outf);
 320
 321         for (i = 0; i <= pkg_dev->levels; ++i) {
 322                 struct isst_pkg_ctdp_level_info *ctdp_level;
 323                 int j;
 324
 325                 ctdp_level = &pkg_dev->ctdp_level[i];
 326                 if (!ctdp_level->processed)
 327                         continue;
 328
 329                 snprintf(header, sizeof(header), "perf-profile-level-%d",
 330                          ctdp_level->level);
 331                 format_and_print(outf, base_level + 3, header, NULL);
 332
 333                 snprintf(header, sizeof(header), "cpu-count");
 334                 j = get_cpu_count(get_physical_die_id(cpu),
 335                                   get_physical_die_id(cpu));
 336                 snprintf(value, sizeof(value), "%d", j);
 337                 format_and_print(outf, base_level + 4, header, value);
 338
 339                 if (ctdp_level->core_cpumask_size) {
 340                         snprintf(header, sizeof(header), "enable-cpu-mask");
 341                         printcpumask(sizeof(value), value,
 342                                      ctdp_level->core_cpumask_size,
 343                                      ctdp_level->core_cpumask);
 344                         format_and_print(outf, base_level + 4, header, value);
 345
 346                         snprintf(header, sizeof(header), "enable-cpu-list");
 347                         printcpulist(sizeof(value), value,
 348                                      ctdp_level->core_cpumask_size,
 349                                      ctdp_level->core_cpumask);
 350                         format_and_print(outf, base_level + 4, header, value);
 351                 }
 352
 353                 snprintf(header, sizeof(header), "thermal-design-power-ratio");
 354                 snprintf(value, sizeof(value), "%d", ctdp_level->tdp_ratio);
 355                 format_and_print(outf, base_level + 4, header, value);
 356
 357                 snprintf(header, sizeof(header), "base-frequency(MHz)");
 358                 if (!ctdp_level->sse_p1)
 359                         ctdp_level->sse_p1 = ctdp_level->tdp_ratio;
 360                 snprintf(value, sizeof(value), "%d",
 361                           ctdp_level->sse_p1 * DISP_FREQ_MULTIPLIER);
 362                 format_and_print(outf, base_level + 4, header, value);
 363
 364                 if (ctdp_level->avx2_p1) {
 365                         snprintf(header, sizeof(header), "base-frequency-avx2(MHz)");
 366                         snprintf(value, sizeof(value), "%d",
 367                                  ctdp_level->avx2_p1 * DISP_FREQ_MULTIPLIER);
 368                         format_and_print(outf, base_level + 4, header, value);
 369                 }
 370
 371                 if (ctdp_level->avx512_p1) {
 372                         snprintf(header, sizeof(header), "base-frequency-avx512(MHz)");
 373                         snprintf(value, sizeof(value), "%d",
 374                                  ctdp_level->avx512_p1 * DISP_FREQ_MULTIPLIER);
 375                         format_and_print(outf, base_level + 4, header, value);
 376                 }
 377
 378                 if (ctdp_level->uncore_p1) {
 379                         snprintf(header, sizeof(header), "uncore-frequency-min(MHz)");
 380                         snprintf(value, sizeof(value), "%d",
 381                                  ctdp_level->uncore_p1 * DISP_FREQ_MULTIPLIER);
 382                         format_and_print(outf, base_level + 4, header, value);
 383                 }
 384
 385                 if (ctdp_level->uncore_p0) {
 386                         snprintf(header, sizeof(header), "uncore-frequency-max(MHz)");
 387                         snprintf(value, sizeof(value), "%d",
 388                                  ctdp_level->uncore_p0 * DISP_FREQ_MULTIPLIER);
 389                         format_and_print(outf, base_level + 4, header, value);
 390                 }
 391
 392                 if (ctdp_level->mem_freq) {
 393                         snprintf(header, sizeof(header), "mem-frequency(MHz)");
 394                         snprintf(value, sizeof(value), "%d",
 395                                  ctdp_level->mem_freq * DISP_FREQ_MULTIPLIER);
 396                         format_and_print(outf, base_level + 4, header, value);
 397                 }
 398
 399                 snprintf(header, sizeof(header),
 400                          "speed-select-turbo-freq");
 401                 if (ctdp_level->fact_support) {
 402                         if (ctdp_level->fact_enabled)
 403                                 snprintf(value, sizeof(value), "enabled");
 404                         else
 405                                 snprintf(value, sizeof(value), "disabled");
 406                 } else
 407                         snprintf(value, sizeof(value), "unsupported");
 408                 format_and_print(outf, base_level + 4, header, value);
 409
 410                 snprintf(header, sizeof(header),
 411                          "speed-select-base-freq");
 412                 if (ctdp_level->pbf_support) {
 413                         if (ctdp_level->pbf_enabled)
 414                                 snprintf(value, sizeof(value), "enabled");
 415                         else
 416                                 snprintf(value, sizeof(value), "disabled");
 417                 } else
 418                         snprintf(value, sizeof(value), "unsupported");
 419                 format_and_print(outf, base_level + 4, header, value);
 420
 421                 snprintf(header, sizeof(header),
 422                          "speed-select-core-power");
 423                 if (ctdp_level->sst_cp_support) {
 424                         if (ctdp_level->sst_cp_enabled)
 425                                 snprintf(value, sizeof(value), "enabled");
 426                         else
 427                                 snprintf(value, sizeof(value), "disabled");
 428                 } else
 429                         snprintf(value, sizeof(value), "unsupported");
 430                 format_and_print(outf, base_level + 4, header, value);
 431
 432                 if (is_clx_n_platform()) {
 433                         if (ctdp_level->pbf_support)
 434                                 _isst_pbf_display_information(cpu, outf,
 435                                                               tdp_level,
 436                                                           &ctdp_level->pbf_info,
 437                                                               base_level + 4);
 438                         continue;
 439                 }
 440
 441                 if (ctdp_level->pkg_tdp) {
 442                         snprintf(header, sizeof(header), "thermal-design-power(W)");
 443                         snprintf(value, sizeof(value), "%d", ctdp_level->pkg_tdp);
 444                         format_and_print(outf, base_level + 4, header, value);
 445                 }
 446
 447                 if (ctdp_level->t_proc_hot) {
 448                         snprintf(header, sizeof(header), "tjunction-max(C)");
 449                         snprintf(value, sizeof(value), "%d", ctdp_level->t_proc_hot);
 450                         format_and_print(outf, base_level + 4, header, value);
 451                 }
 452
 453                 snprintf(header, sizeof(header), "turbo-ratio-limits-sse");
 454                 format_and_print(outf, base_level + 4, header, NULL);
 455                 for (j = 0; j < 8; ++j) {
 456                         snprintf(header, sizeof(header), "bucket-%d", j);
 457                         format_and_print(outf, base_level + 5, header, NULL);
 458
 459                         snprintf(header, sizeof(header), "core-count");
 460                         snprintf(value, sizeof(value), "%llu", (ctdp_level->buckets_info >> (j * 8)) & 0xff);
 461                         format_and_print(outf, base_level + 6, header, value);
 462
 463                         snprintf(header, sizeof(header),
 464                                 "max-turbo-frequency(MHz)");
 465                         snprintf(value, sizeof(value), "%d",
 466                                  ctdp_level->trl_sse_active_cores[j] *
 467                                   DISP_FREQ_MULTIPLIER);
 468                         format_and_print(outf, base_level + 6, header, value);
 469                 }
 470
 471                 if (ctdp_level->trl_avx_active_cores[0]) {
 472                         snprintf(header, sizeof(header), "turbo-ratio-limits-avx2");
 473                         format_and_print(outf, base_level + 4, header, NULL);
 474                         for (j = 0; j < 8; ++j) {
 475                                 snprintf(header, sizeof(header), "bucket-%d", j);
 476                                 format_and_print(outf, base_level + 5, header, NULL);
 477
 478                                 snprintf(header, sizeof(header), "core-count");
 479                                 snprintf(value, sizeof(value), "%llu", (ctdp_level->buckets_info >> (j * 8)) & 0xff);
 480                                 format_and_print(outf, base_level + 6, header, value);
 481
 482                                 snprintf(header, sizeof(header), "max-turbo-frequency(MHz)");
 483                                 snprintf(value, sizeof(value), "%d", ctdp_level->trl_avx_active_cores[j] * DISP_FREQ_MULTIPLIER);
 484                                 format_and_print(outf, base_level + 6, header, value);
 485                         }
 486                 }
 487
 488                 if (ctdp_level->trl_avx_512_active_cores[0]) {
 489                         snprintf(header, sizeof(header), "turbo-ratio-limits-avx512");
 490                         format_and_print(outf, base_level + 4, header, NULL);
 491                         for (j = 0; j < 8; ++j) {
 492                                 snprintf(header, sizeof(header), "bucket-%d", j);
 493                                 format_and_print(outf, base_level + 5, header, NULL);
 494
 495                                 snprintf(header, sizeof(header), "core-count");
 496                                 snprintf(value, sizeof(value), "%llu", (ctdp_level->buckets_info >> (j * 8)) & 0xff);
 497                                 format_and_print(outf, base_level + 6, header, value);
 498
 499                                 snprintf(header, sizeof(header), "max-turbo-frequency(MHz)");
 500                                 snprintf(value, sizeof(value), "%d", ctdp_level->trl_avx_512_active_cores[j] * DISP_FREQ_MULTIPLIER);
 501                         format_and_print(outf, base_level + 6, header, value);
 502                         }
 503                 }
 504
 505                 if (ctdp_level->pbf_support)
 506                         _isst_pbf_display_information(cpu, outf, i,
 507                                                       &ctdp_level->pbf_info,
 508                                                       base_level + 4);
 509                 if (ctdp_level->fact_support)
 510                         _isst_fact_display_information(cpu, outf, i, 0xff, 0xff,
 511                                                        &ctdp_level->fact_info,
 512                                                        base_level + 4);
 513         }
 514
 515         format_and_print(outf, 1, NULL, NULL);
 516 }
 517
 518 void isst_ctdp_display_information_start(FILE *outf)
 519 {
 520         last_level = 0;
 521         format_and_print(outf, 0, "start", NULL);
 522 }
 523
 524 void isst_ctdp_display_information_end(FILE *outf)
 525 {
 526         format_and_print(outf, 0, NULL, NULL);
 527 }
 528
 529 void isst_pbf_display_information(int cpu, FILE *outf, int level,
 530                                   struct isst_pbf_info *pbf_info)
 531 {
 532         print_package_info(cpu, outf);
 533         _isst_pbf_display_information(cpu, outf, level, pbf_info, 4);
 534         format_and_print(outf, 1, NULL, NULL);
 535 }
 536
 537 void isst_fact_display_information(int cpu, FILE *outf, int level,
 538                                    int fact_bucket, int fact_avx,
 539                                    struct isst_fact_info *fact_info)
 540 {
 541         print_package_info(cpu, outf);
 542         _isst_fact_display_information(cpu, outf, level, fact_bucket, fact_avx,
 543                                        fact_info, 4);
 544         format_and_print(outf, 1, NULL, NULL);
 545 }
 546
 547 void isst_clos_display_information(int cpu, FILE *outf, int clos,
 548                                    struct isst_clos_config *clos_config)
 549 {
 550         char header[256];
 551         char value[256];
 552
 553         snprintf(header, sizeof(header), "package-%d",
 554                  get_physical_package_id(cpu));
 555         format_and_print(outf, 1, header, NULL);
 556         snprintf(header, sizeof(header), "die-%d", get_physical_die_id(cpu));
 557         format_and_print(outf, 2, header, NULL);
 558         snprintf(header, sizeof(header), "cpu-%d", cpu);
 559         format_and_print(outf, 3, header, NULL);
 560
 561         snprintf(header, sizeof(header), "core-power");
 562         format_and_print(outf, 4, header, NULL);
 563
 564         snprintf(header, sizeof(header), "clos");
 565         snprintf(value, sizeof(value), "%d", clos);
 566         format_and_print(outf, 5, header, value);
 567
 568         snprintf(header, sizeof(header), "epp");
 569         snprintf(value, sizeof(value), "%d", clos_config->epp);
 570         format_and_print(outf, 5, header, value);
 571
 572         snprintf(header, sizeof(header), "clos-proportional-priority");
 573         snprintf(value, sizeof(value), "%d", clos_config->clos_prop_prio);
 574         format_and_print(outf, 5, header, value);
 575
 576         snprintf(header, sizeof(header), "clos-min");
 577         snprintf(value, sizeof(value), "%d MHz", clos_config->clos_min * DISP_FREQ_MULTIPLIER);
 578         format_and_print(outf, 5, header, value);
 579
 580         snprintf(header, sizeof(header), "clos-max");
 581         snprintf(value, sizeof(value), "%d MHz", clos_config->clos_max * DISP_FREQ_MULTIPLIER);
 582         format_and_print(outf, 5, header, value);
 583
 584         snprintf(header, sizeof(header), "clos-desired");
 585         snprintf(value, sizeof(value), "%d MHz", clos_config->clos_desired * DISP_FREQ_MULTIPLIER);
 586         format_and_print(outf, 5, header, value);
 587
 588         format_and_print(outf, 1, NULL, NULL);
 589 }
 590
 591 void isst_clos_display_clos_information(int cpu, FILE *outf,
 592                                         int clos_enable, int type)
 593 {
 594         char header[256];
 595         char value[256];
 596
 597         snprintf(header, sizeof(header), "package-%d",
 598                  get_physical_package_id(cpu));
 599         format_and_print(outf, 1, header, NULL);
 600         snprintf(header, sizeof(header), "die-%d", get_physical_die_id(cpu));
 601         format_and_print(outf, 2, header, NULL);
 602         snprintf(header, sizeof(header), "cpu-%d", cpu);
 603         format_and_print(outf, 3, header, NULL);
 604
 605         snprintf(header, sizeof(header), "core-power");
 606         format_and_print(outf, 4, header, NULL);
 607
 608         snprintf(header, sizeof(header), "enable-status");
 609         snprintf(value, sizeof(value), "%d", clos_enable);
 610         format_and_print(outf, 5, header, value);
 611
 612         snprintf(header, sizeof(header), "priority-type");
 613         snprintf(value, sizeof(value), "%d", type);
 614         format_and_print(outf, 5, header, value);
 615
 616         format_and_print(outf, 1, NULL, NULL);
 617 }
 618
 619 void isst_clos_display_assoc_information(int cpu, FILE *outf, int clos)
 620 {
 621         char header[256];
 622         char value[256];
 623
 624         snprintf(header, sizeof(header), "package-%d",
 625                  get_physical_package_id(cpu));
 626         format_and_print(outf, 1, header, NULL);
 627         snprintf(header, sizeof(header), "die-%d", get_physical_die_id(cpu));
 628         format_and_print(outf, 2, header, NULL);
 629         snprintf(header, sizeof(header), "cpu-%d", cpu);
 630         format_and_print(outf, 3, header, NULL);
 631
 632         snprintf(header, sizeof(header), "get-assoc");
 633         format_and_print(outf, 4, header, NULL);
 634
 635         snprintf(header, sizeof(header), "clos");
 636         snprintf(value, sizeof(value), "%d", clos);
 637         format_and_print(outf, 5, header, value);
 638
 639         format_and_print(outf, 1, NULL, NULL);
 640 }
 641
 642 void isst_display_result(int cpu, FILE *outf, char *feature, char *cmd,
 643                          int result)
 644 {
 645         char header[256];
 646         char value[256];
 647
 648         if (cpu >= 0) {
 649                 snprintf(header, sizeof(header), "package-%d",
 650                          get_physical_package_id(cpu));
 651                 format_and_print(outf, 1, header, NULL);
 652                 snprintf(header, sizeof(header), "die-%d", get_physical_die_id(cpu));
 653                 format_and_print(outf, 2, header, NULL);
 654                 snprintf(header, sizeof(header), "cpu-%d", cpu);
 655                 format_and_print(outf, 3, header, NULL);
 656         }
 657         snprintf(header, sizeof(header), "%s", feature);
 658         format_and_print(outf, 4, header, NULL);
 659         snprintf(header, sizeof(header), "%s", cmd);
 660         if (!result)
 661                 snprintf(value, sizeof(value), "success");
 662         else
 663                 snprintf(value, sizeof(value), "failed(error %d)", result);
 664         format_and_print(outf, 5, header, value);
 665
 666         format_and_print(outf, 1, NULL, NULL);
 667 }