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 int print_package_info(int cpu, FILE *outf)
 162 {
 163         char header[256];
 164
 165         if (out_format_is_json()) {
 166                 snprintf(header, sizeof(header), "package-%d:die-%d:cpu-%d",
 167                          get_physical_package_id(cpu), get_physical_die_id(cpu),
 168                          cpu);
 169                 format_and_print(outf, 1, header, NULL);
 170                 return 1;
 171         }
 172         snprintf(header, sizeof(header), "package-%d",
 173                  get_physical_package_id(cpu));
 174         format_and_print(outf, 1, header, NULL);
 175         snprintf(header, sizeof(header), "die-%d", get_physical_die_id(cpu));
 176         format_and_print(outf, 2, header, NULL);
 177         snprintf(header, sizeof(header), "cpu-%d", cpu);
 178         format_and_print(outf, 3, header, NULL);
 179
 180         return 3;
 181 }
 182
 183 static void _isst_pbf_display_information(int cpu, FILE *outf, int level,
 184                                           struct isst_pbf_info *pbf_info,
 185                                           int disp_level)
 186 {
 187         char header[256];
 188         char value[256];
 189
 190         snprintf(header, sizeof(header), "speed-select-base-freq-properties");
 191         format_and_print(outf, disp_level, header, NULL);
 192
 193         snprintf(header, sizeof(header), "high-priority-base-frequency(MHz)");
 194         snprintf(value, sizeof(value), "%d",
 195                  pbf_info->p1_high * DISP_FREQ_MULTIPLIER);
 196         format_and_print(outf, disp_level + 1, header, value);
 197
 198         snprintf(header, sizeof(header), "high-priority-cpu-mask");
 199         printcpumask(sizeof(value), value, pbf_info->core_cpumask_size,
 200                      pbf_info->core_cpumask);
 201         format_and_print(outf, disp_level + 1, header, value);
 202
 203         snprintf(header, sizeof(header), "high-priority-cpu-list");
 204         printcpulist(sizeof(value), value,
 205                      pbf_info->core_cpumask_size,
 206                      pbf_info->core_cpumask);
 207         format_and_print(outf, disp_level + 1, header, value);
 208
 209         snprintf(header, sizeof(header), "low-priority-base-frequency(MHz)");
 210         snprintf(value, sizeof(value), "%d",
 211                  pbf_info->p1_low * DISP_FREQ_MULTIPLIER);
 212         format_and_print(outf, disp_level + 1, header, value);
 213
 214         if (is_clx_n_platform())
 215                 return;
 216
 217         snprintf(header, sizeof(header), "tjunction-temperature(C)");
 218         snprintf(value, sizeof(value), "%d", pbf_info->t_prochot);
 219         format_and_print(outf, disp_level + 1, header, value);
 220
 221         snprintf(header, sizeof(header), "thermal-design-power(W)");
 222         snprintf(value, sizeof(value), "%d", pbf_info->tdp);
 223         format_and_print(outf, disp_level + 1, header, value);
 224 }
 225
 226 static void _isst_fact_display_information(int cpu, FILE *outf, int level,
 227                                            int fact_bucket, int fact_avx,
 228                                            struct isst_fact_info *fact_info,
 229                                            int base_level)
 230 {
 231         struct isst_fact_bucket_info *bucket_info = fact_info->bucket_info;
 232         char header[256];
 233         char value[256];
 234         int print = 0, j;
 235
 236         for (j = 0; j < ISST_FACT_MAX_BUCKETS; ++j) {
 237                 if (fact_bucket != 0xff && fact_bucket != j)
 238                         continue;
 239
 240                 if (!bucket_info[j].high_priority_cores_count)
 241                         break;
 242
 243                 print = 1;
 244         }
 245         if (!print) {
 246                 fprintf(stderr, "Invalid bucket\n");
 247                 return;
 248         }
 249
 250         snprintf(header, sizeof(header), "speed-select-turbo-freq-properties");
 251         format_and_print(outf, base_level, header, NULL);
 252         for (j = 0; j < ISST_FACT_MAX_BUCKETS; ++j) {
 253                 if (fact_bucket != 0xff && fact_bucket != j)
 254                         continue;
 255
 256                 if (!bucket_info[j].high_priority_cores_count)
 257                         break;
 258
 259                 snprintf(header, sizeof(header), "bucket-%d", j);
 260                 format_and_print(outf, base_level + 1, header, NULL);
 261
 262                 snprintf(header, sizeof(header), "high-priority-cores-count");
 263                 snprintf(value, sizeof(value), "%d",
 264                          bucket_info[j].high_priority_cores_count);
 265                 format_and_print(outf, base_level + 2, header, value);
 266
 267                 if (fact_avx & 0x01) {
 268                         snprintf(header, sizeof(header),
 269                                  "high-priority-max-frequency(MHz)");
 270                         snprintf(value, sizeof(value), "%d",
 271                                  bucket_info[j].sse_trl * DISP_FREQ_MULTIPLIER);
 272                         format_and_print(outf, base_level + 2, header, value);
 273                 }
 274
 275                 if (fact_avx & 0x02) {
 276                         snprintf(header, sizeof(header),
 277                                  "high-priority-max-avx2-frequency(MHz)");
 278                         snprintf(value, sizeof(value), "%d",
 279                                  bucket_info[j].avx_trl * DISP_FREQ_MULTIPLIER);
 280                         format_and_print(outf, base_level + 2, header, value);
 281                 }
 282
 283                 if (fact_avx & 0x04) {
 284                         snprintf(header, sizeof(header),
 285                                  "high-priority-max-avx512-frequency(MHz)");
 286                         snprintf(value, sizeof(value), "%d",
 287                                  bucket_info[j].avx512_trl *
 288                                          DISP_FREQ_MULTIPLIER);
 289                         format_and_print(outf, base_level + 2, header, value);
 290                 }
 291         }
 292         snprintf(header, sizeof(header),
 293                  "speed-select-turbo-freq-clip-frequencies");
 294         format_and_print(outf, base_level + 1, header, NULL);
 295         snprintf(header, sizeof(header), "low-priority-max-frequency(MHz)");
 296         snprintf(value, sizeof(value), "%d",
 297                  fact_info->lp_clipping_ratio_license_sse *
 298                          DISP_FREQ_MULTIPLIER);
 299         format_and_print(outf, base_level + 2, header, value);
 300         snprintf(header, sizeof(header),
 301                  "low-priority-max-avx2-frequency(MHz)");
 302         snprintf(value, sizeof(value), "%d",
 303                  fact_info->lp_clipping_ratio_license_avx2 *
 304                          DISP_FREQ_MULTIPLIER);
 305         format_and_print(outf, base_level + 2, header, value);
 306         snprintf(header, sizeof(header),
 307                  "low-priority-max-avx512-frequency(MHz)");
 308         snprintf(value, sizeof(value), "%d",
 309                  fact_info->lp_clipping_ratio_license_avx512 *
 310                          DISP_FREQ_MULTIPLIER);
 311         format_and_print(outf, base_level + 2, header, value);
 312 }
 313
 314 void isst_ctdp_display_core_info(int cpu, FILE *outf, char *prefix,
 315                                  unsigned int val, char *str0, char *str1)
 316 {
 317         char header[256];
 318         char value[256];
 319         int level = 1;
 320
 321         if (out_format_is_json()) {
 322                 snprintf(header, sizeof(header), "package-%d:die-%d:cpu-%d",
 323                          get_physical_package_id(cpu), get_physical_die_id(cpu),
 324                          cpu);
 325                 format_and_print(outf, level++, header, NULL);
 326         } else {
 327                 snprintf(header, sizeof(header), "package-%d",
 328                          get_physical_package_id(cpu));
 329                 format_and_print(outf, level++, header, NULL);
 330                 snprintf(header, sizeof(header), "die-%d",
 331                          get_physical_die_id(cpu));
 332                 format_and_print(outf, level++, header, NULL);
 333                 snprintf(header, sizeof(header), "cpu-%d", cpu);
 334                 format_and_print(outf, level++, header, NULL);
 335         }
 336
 337         if (str0 && !val)
 338                 snprintf(value, sizeof(value), "%s", str0);
 339         else if (str1 && val)
 340                 snprintf(value, sizeof(value), "%s", str1);
 341         else
 342                 snprintf(value, sizeof(value), "%u", val);
 343         format_and_print(outf, level, prefix, value);
 344
 345         format_and_print(outf, 1, NULL, NULL);
 346 }
 347
 348 void isst_ctdp_display_information(int cpu, FILE *outf, int tdp_level,
 349                                    struct isst_pkg_ctdp *pkg_dev)
 350 {
 351         char header[256];
 352         char value[256];
 353         static int level;
 354         int i;
 355
 356         if (pkg_dev->processed)
 357                 level = print_package_info(cpu, outf);
 358
 359         for (i = 0; i <= pkg_dev->levels; ++i) {
 360                 struct isst_pkg_ctdp_level_info *ctdp_level;
 361                 int j;
 362
 363                 ctdp_level = &pkg_dev->ctdp_level[i];
 364                 if (!ctdp_level->processed)
 365                         continue;
 366
 367                 snprintf(header, sizeof(header), "perf-profile-level-%d",
 368                          ctdp_level->level);
 369                 format_and_print(outf, level + 1, header, NULL);
 370
 371                 snprintf(header, sizeof(header), "cpu-count");
 372                 j = get_cpu_count(get_physical_die_id(cpu),
 373                                   get_physical_die_id(cpu));
 374                 snprintf(value, sizeof(value), "%d", j);
 375                 format_and_print(outf, level + 2, header, value);
 376
 377                 j = CPU_COUNT_S(ctdp_level->core_cpumask_size,
 378                                 ctdp_level->core_cpumask);
 379                 if (j) {
 380                         snprintf(header, sizeof(header), "enable-cpu-count");
 381                         snprintf(value, sizeof(value), "%d", j);
 382                         format_and_print(outf, level + 2, header, value);
 383                 }
 384
 385                 if (ctdp_level->core_cpumask_size) {
 386                         snprintf(header, sizeof(header), "enable-cpu-mask");
 387                         printcpumask(sizeof(value), value,
 388                                      ctdp_level->core_cpumask_size,
 389                                      ctdp_level->core_cpumask);
 390                         format_and_print(outf, level + 2, header, value);
 391
 392                         snprintf(header, sizeof(header), "enable-cpu-list");
 393                         printcpulist(sizeof(value), value,
 394                                      ctdp_level->core_cpumask_size,
 395                                      ctdp_level->core_cpumask);
 396                         format_and_print(outf, level + 2, header, value);
 397                 }
 398
 399                 snprintf(header, sizeof(header), "thermal-design-power-ratio");
 400                 snprintf(value, sizeof(value), "%d", ctdp_level->tdp_ratio);
 401                 format_and_print(outf, level + 2, header, value);
 402
 403                 snprintf(header, sizeof(header), "base-frequency(MHz)");
 404                 if (!ctdp_level->sse_p1)
 405                         ctdp_level->sse_p1 = ctdp_level->tdp_ratio;
 406                 snprintf(value, sizeof(value), "%d",
 407                           ctdp_level->sse_p1 * DISP_FREQ_MULTIPLIER);
 408                 format_and_print(outf, level + 2, header, value);
 409
 410                 if (ctdp_level->avx2_p1) {
 411                         snprintf(header, sizeof(header), "base-frequency-avx2(MHz)");
 412                         snprintf(value, sizeof(value), "%d",
 413                                  ctdp_level->avx2_p1 * DISP_FREQ_MULTIPLIER);
 414                         format_and_print(outf, level + 2, header, value);
 415                 }
 416
 417                 if (ctdp_level->avx512_p1) {
 418                         snprintf(header, sizeof(header), "base-frequency-avx512(MHz)");
 419                         snprintf(value, sizeof(value), "%d",
 420                                  ctdp_level->avx512_p1 * DISP_FREQ_MULTIPLIER);
 421                         format_and_print(outf, level + 2, header, value);
 422                 }
 423
 424                 if (ctdp_level->uncore_p1) {
 425                         snprintf(header, sizeof(header), "uncore-frequency-min(MHz)");
 426                         snprintf(value, sizeof(value), "%d",
 427                                  ctdp_level->uncore_p1 * DISP_FREQ_MULTIPLIER);
 428                         format_and_print(outf, level + 2, header, value);
 429                 }
 430
 431                 if (ctdp_level->uncore_p0) {
 432                         snprintf(header, sizeof(header), "uncore-frequency-max(MHz)");
 433                         snprintf(value, sizeof(value), "%d",
 434                                  ctdp_level->uncore_p0 * DISP_FREQ_MULTIPLIER);
 435                         format_and_print(outf, level + 2, header, value);
 436                 }
 437
 438                 if (ctdp_level->mem_freq) {
 439                         snprintf(header, sizeof(header), "mem-frequency(MHz)");
 440                         snprintf(value, sizeof(value), "%d",
 441                                  ctdp_level->mem_freq * DISP_FREQ_MULTIPLIER);
 442                         format_and_print(outf, level + 2, header, value);
 443                 }
 444
 445                 snprintf(header, sizeof(header),
 446                          "speed-select-turbo-freq");
 447                 if (ctdp_level->fact_support) {
 448                         if (ctdp_level->fact_enabled)
 449                                 snprintf(value, sizeof(value), "enabled");
 450                         else
 451                                 snprintf(value, sizeof(value), "disabled");
 452                 } else
 453                         snprintf(value, sizeof(value), "unsupported");
 454                 format_and_print(outf, level + 2, header, value);
 455
 456                 snprintf(header, sizeof(header),
 457                          "speed-select-base-freq");
 458                 if (ctdp_level->pbf_support) {
 459                         if (ctdp_level->pbf_enabled)
 460                                 snprintf(value, sizeof(value), "enabled");
 461                         else
 462                                 snprintf(value, sizeof(value), "disabled");
 463                 } else
 464                         snprintf(value, sizeof(value), "unsupported");
 465                 format_and_print(outf, level + 2, header, value);
 466
 467                 snprintf(header, sizeof(header),
 468                          "speed-select-core-power");
 469                 if (ctdp_level->sst_cp_support) {
 470                         if (ctdp_level->sst_cp_enabled)
 471                                 snprintf(value, sizeof(value), "enabled");
 472                         else
 473                                 snprintf(value, sizeof(value), "disabled");
 474                 } else
 475                         snprintf(value, sizeof(value), "unsupported");
 476                 format_and_print(outf, level + 2, header, value);
 477
 478                 if (is_clx_n_platform()) {
 479                         if (ctdp_level->pbf_support)
 480                                 _isst_pbf_display_information(cpu, outf,
 481                                                               tdp_level,
 482                                                           &ctdp_level->pbf_info,
 483                                                               level + 2);
 484                         continue;
 485                 }
 486
 487                 if (ctdp_level->pkg_tdp) {
 488                         snprintf(header, sizeof(header), "thermal-design-power(W)");
 489                         snprintf(value, sizeof(value), "%d", ctdp_level->pkg_tdp);
 490                         format_and_print(outf, level + 2, header, value);
 491                 }
 492
 493                 if (ctdp_level->t_proc_hot) {
 494                         snprintf(header, sizeof(header), "tjunction-max(C)");
 495                         snprintf(value, sizeof(value), "%d", ctdp_level->t_proc_hot);
 496                         format_and_print(outf, level + 2, header, value);
 497                 }
 498
 499                 snprintf(header, sizeof(header), "turbo-ratio-limits-sse");
 500                 format_and_print(outf, level + 2, header, NULL);
 501                 for (j = 0; j < 8; ++j) {
 502                         snprintf(header, sizeof(header), "bucket-%d", j);
 503                         format_and_print(outf, level + 3, header, NULL);
 504
 505                         snprintf(header, sizeof(header), "core-count");
 506                         snprintf(value, sizeof(value), "%llu", (ctdp_level->buckets_info >> (j * 8)) & 0xff);
 507                         format_and_print(outf, level + 4, header, value);
 508
 509                         snprintf(header, sizeof(header),
 510                                 "max-turbo-frequency(MHz)");
 511                         snprintf(value, sizeof(value), "%d",
 512                                  ctdp_level->trl_sse_active_cores[j] *
 513                                   DISP_FREQ_MULTIPLIER);
 514                         format_and_print(outf, level + 4, header, value);
 515                 }
 516
 517                 if (ctdp_level->trl_avx_active_cores[0]) {
 518                         snprintf(header, sizeof(header), "turbo-ratio-limits-avx2");
 519                         format_and_print(outf, level + 2, header, NULL);
 520                         for (j = 0; j < 8; ++j) {
 521                                 snprintf(header, sizeof(header), "bucket-%d", j);
 522                                 format_and_print(outf, level + 3, header, NULL);
 523
 524                                 snprintf(header, sizeof(header), "core-count");
 525                                 snprintf(value, sizeof(value), "%llu", (ctdp_level->buckets_info >> (j * 8)) & 0xff);
 526                                 format_and_print(outf, level + 4, header, value);
 527
 528                                 snprintf(header, sizeof(header), "max-turbo-frequency(MHz)");
 529                                 snprintf(value, sizeof(value), "%d", ctdp_level->trl_avx_active_cores[j] * DISP_FREQ_MULTIPLIER);
 530                                 format_and_print(outf, level + 4, header, value);
 531                         }
 532                 }
 533
 534                 if (ctdp_level->trl_avx_512_active_cores[0]) {
 535                         snprintf(header, sizeof(header), "turbo-ratio-limits-avx512");
 536                         format_and_print(outf, level + 2, header, NULL);
 537                         for (j = 0; j < 8; ++j) {
 538                                 snprintf(header, sizeof(header), "bucket-%d", j);
 539                                 format_and_print(outf, level + 3, header, NULL);
 540
 541                                 snprintf(header, sizeof(header), "core-count");
 542                                 snprintf(value, sizeof(value), "%llu", (ctdp_level->buckets_info >> (j * 8)) & 0xff);
 543                                 format_and_print(outf, level + 4, header, value);
 544
 545                                 snprintf(header, sizeof(header), "max-turbo-frequency(MHz)");
 546                                 snprintf(value, sizeof(value), "%d", ctdp_level->trl_avx_512_active_cores[j] * DISP_FREQ_MULTIPLIER);
 547                                 format_and_print(outf, level + 4, header, value);
 548                         }
 549                 }
 550
 551                 if (ctdp_level->pbf_support)
 552                         _isst_pbf_display_information(cpu, outf, i,
 553                                                       &ctdp_level->pbf_info,
 554                                                       level + 2);
 555                 if (ctdp_level->fact_support)
 556                         _isst_fact_display_information(cpu, outf, i, 0xff, 0xff,
 557                                                        &ctdp_level->fact_info,
 558                                                        level + 2);
 559         }
 560
 561         format_and_print(outf, 1, NULL, NULL);
 562 }
 563
 564 static int start;
 565 void isst_ctdp_display_information_start(FILE *outf)
 566 {
 567         last_level = 0;
 568         format_and_print(outf, 0, "start", NULL);
 569         start = 1;
 570 }
 571
 572 void isst_ctdp_display_information_end(FILE *outf)
 573 {
 574         format_and_print(outf, 0, NULL, NULL);
 575         start = 0;
 576 }
 577
 578 void isst_pbf_display_information(int cpu, FILE *outf, int level,
 579                                   struct isst_pbf_info *pbf_info)
 580 {
 581         int _level;
 582
 583         _level = print_package_info(cpu, outf);
 584         _isst_pbf_display_information(cpu, outf, level, pbf_info, _level + 1);
 585         format_and_print(outf, 1, NULL, NULL);
 586 }
 587
 588 void isst_fact_display_information(int cpu, FILE *outf, int level,
 589                                    int fact_bucket, int fact_avx,
 590                                    struct isst_fact_info *fact_info)
 591 {
 592         int _level;
 593
 594         _level = print_package_info(cpu, outf);
 595         _isst_fact_display_information(cpu, outf, level, fact_bucket, fact_avx,
 596                                        fact_info, _level + 1);
 597         format_and_print(outf, 1, NULL, NULL);
 598 }
 599
 600 void isst_clos_display_information(int cpu, FILE *outf, int clos,
 601                                    struct isst_clos_config *clos_config)
 602 {
 603         char header[256];
 604         char value[256];
 605         int level;
 606
 607         level = print_package_info(cpu, outf);
 608
 609         snprintf(header, sizeof(header), "core-power");
 610         format_and_print(outf, level + 1, header, NULL);
 611
 612         snprintf(header, sizeof(header), "clos");
 613         snprintf(value, sizeof(value), "%d", clos);
 614         format_and_print(outf, level + 2, header, value);
 615
 616         snprintf(header, sizeof(header), "epp");
 617         snprintf(value, sizeof(value), "%d", clos_config->epp);
 618         format_and_print(outf, level + 2, header, value);
 619
 620         snprintf(header, sizeof(header), "clos-proportional-priority");
 621         snprintf(value, sizeof(value), "%d", clos_config->clos_prop_prio);
 622         format_and_print(outf, level + 2, header, value);
 623
 624         snprintf(header, sizeof(header), "clos-min");
 625         snprintf(value, sizeof(value), "%d MHz", clos_config->clos_min * DISP_FREQ_MULTIPLIER);
 626         format_and_print(outf, level + 2, header, value);
 627
 628         snprintf(header, sizeof(header), "clos-max");
 629         if (clos_config->clos_max == 0xff)
 630                 snprintf(value, sizeof(value), "Max Turbo frequency");
 631         else
 632                 snprintf(value, sizeof(value), "%d MHz", clos_config->clos_max * DISP_FREQ_MULTIPLIER);
 633         format_and_print(outf, level + 2, header, value);
 634
 635         snprintf(header, sizeof(header), "clos-desired");
 636         snprintf(value, sizeof(value), "%d MHz", clos_config->clos_desired * DISP_FREQ_MULTIPLIER);
 637         format_and_print(outf, level + 2, header, value);
 638
 639         format_and_print(outf, level, NULL, NULL);
 640 }
 641
 642 void isst_clos_display_clos_information(int cpu, FILE *outf,
 643                                         int clos_enable, int type,
 644                                         int state, int cap)
 645 {
 646         char header[256];
 647         char value[256];
 648         int level;
 649
 650         level = print_package_info(cpu, outf);
 651
 652         snprintf(header, sizeof(header), "core-power");
 653         format_and_print(outf, level + 1, header, NULL);
 654
 655         snprintf(header, sizeof(header), "support-status");
 656         if (cap)
 657                 snprintf(value, sizeof(value), "supported");
 658         else
 659                 snprintf(value, sizeof(value), "unsupported");
 660         format_and_print(outf, level + 2, header, value);
 661
 662         snprintf(header, sizeof(header), "enable-status");
 663         if (state)
 664                 snprintf(value, sizeof(value), "enabled");
 665         else
 666                 snprintf(value, sizeof(value), "disabled");
 667         format_and_print(outf, level + 2, header, value);
 668
 669         snprintf(header, sizeof(header), "clos-enable-status");
 670         if (clos_enable)
 671                 snprintf(value, sizeof(value), "enabled");
 672         else
 673                 snprintf(value, sizeof(value), "disabled");
 674         format_and_print(outf, level + 2, header, value);
 675
 676         snprintf(header, sizeof(header), "priority-type");
 677         if (type)
 678                 snprintf(value, sizeof(value), "ordered");
 679         else
 680                 snprintf(value, sizeof(value), "proportional");
 681         format_and_print(outf, level + 2, header, value);
 682
 683         format_and_print(outf, level, NULL, NULL);
 684 }
 685
 686 void isst_clos_display_assoc_information(int cpu, FILE *outf, int clos)
 687 {
 688         char header[256];
 689         char value[256];
 690         int level;
 691
 692         level = print_package_info(cpu, outf);
 693
 694         snprintf(header, sizeof(header), "get-assoc");
 695         format_and_print(outf, level + 1, header, NULL);
 696
 697         snprintf(header, sizeof(header), "clos");
 698         snprintf(value, sizeof(value), "%d", clos);
 699         format_and_print(outf, level + 2, header, value);
 700
 701         format_and_print(outf, level, NULL, NULL);
 702 }
 703
 704 void isst_display_result(int cpu, FILE *outf, char *feature, char *cmd,
 705                          int result)
 706 {
 707         char header[256];
 708         char value[256];
 709         int level = 3;
 710
 711         if (cpu >= 0)
 712                 level = print_package_info(cpu, outf);
 713
 714         snprintf(header, sizeof(header), "%s", feature);
 715         format_and_print(outf, level + 1, header, NULL);
 716         snprintf(header, sizeof(header), "%s", cmd);
 717         if (!result)
 718                 snprintf(value, sizeof(value), "success");
 719         else
 720                 snprintf(value, sizeof(value), "failed(error %d)", result);
 721         format_and_print(outf, level + 2, header, value);
 722
 723         format_and_print(outf, level, NULL, NULL);
 724 }
 725
 726 void isst_display_error_info_message(int error, char *msg, int arg_valid, int arg)
 727 {
 728         FILE *outf = get_output_file();
 729         static int error_index;
 730         char header[256];
 731         char value[256];
 732
 733         if (!out_format_is_json()) {
 734                 if (arg_valid)
 735                         snprintf(value, sizeof(value), "%s %d", msg, arg);
 736                 else
 737                         snprintf(value, sizeof(value), "%s", msg);
 738
 739                 if (error)
 740                         fprintf(outf, "Error: %s\n", value);
 741                 else
 742                         fprintf(outf, "Information: %s\n", value);
 743                 return;
 744         }
 745
 746         if (!start)
 747                 format_and_print(outf, 0, "start", NULL);
 748
 749         if (error)
 750                 snprintf(header, sizeof(header), "Error%d", error_index++);
 751         else
 752                 snprintf(header, sizeof(header), "Information:%d", error_index++);
 753         format_and_print(outf, 1, header, NULL);
 754
 755         snprintf(header, sizeof(header), "message");
 756         if (arg_valid)
 757                 snprintf(value, sizeof(value), "%s %d", msg, arg);
 758         else
 759                 snprintf(value, sizeof(value), "%s", msg);
 760
 761         format_and_print(outf, 2, header, value);
 762         format_and_print(outf, 1, NULL, NULL);
 763         if (!start)
 764                 format_and_print(outf, 0, NULL, NULL);
 765 }