Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Intel dynamic_speed_select -- Enumerate and control features
0004  * Copyright (c) 2019 Intel Corporation.
0005  */
0006 
0007 #include "isst.h"
0008 
0009 static void printcpulist(int str_len, char *str, int mask_size,
0010              cpu_set_t *cpu_mask)
0011 {
0012     int i, first, curr_index, index;
0013 
0014     if (!CPU_COUNT_S(mask_size, cpu_mask)) {
0015         snprintf(str, str_len, "none");
0016         return;
0017     }
0018 
0019     curr_index = 0;
0020     first = 1;
0021     for (i = 0; i < get_topo_max_cpus(); ++i) {
0022         if (!CPU_ISSET_S(i, mask_size, cpu_mask))
0023             continue;
0024         if (!first) {
0025             index = snprintf(&str[curr_index],
0026                      str_len - curr_index, ",");
0027             curr_index += index;
0028             if (curr_index >= str_len)
0029                 break;
0030         }
0031         index = snprintf(&str[curr_index], str_len - curr_index, "%d",
0032                  i);
0033         curr_index += index;
0034         if (curr_index >= str_len)
0035             break;
0036         first = 0;
0037     }
0038 }
0039 
0040 static void printcpumask(int str_len, char *str, int mask_size,
0041              cpu_set_t *cpu_mask)
0042 {
0043     int i, max_cpus = get_topo_max_cpus();
0044     unsigned int *mask;
0045     int size, index, curr_index;
0046 
0047     size = max_cpus / (sizeof(unsigned int) * 8);
0048     if (max_cpus % (sizeof(unsigned int) * 8))
0049         size++;
0050 
0051     mask = calloc(size, sizeof(unsigned int));
0052     if (!mask)
0053         return;
0054 
0055     for (i = 0; i < max_cpus; ++i) {
0056         int mask_index, bit_index;
0057 
0058         if (!CPU_ISSET_S(i, mask_size, cpu_mask))
0059             continue;
0060 
0061         mask_index = i / (sizeof(unsigned int) * 8);
0062         bit_index = i % (sizeof(unsigned int) * 8);
0063         mask[mask_index] |= BIT(bit_index);
0064     }
0065 
0066     curr_index = 0;
0067     for (i = size - 1; i >= 0; --i) {
0068         index = snprintf(&str[curr_index], str_len - curr_index, "%08x",
0069                  mask[i]);
0070         curr_index += index;
0071         if (curr_index >= str_len)
0072             break;
0073         if (i) {
0074             strncat(&str[curr_index], ",", str_len - curr_index);
0075             curr_index++;
0076         }
0077         if (curr_index >= str_len)
0078             break;
0079     }
0080 
0081     free(mask);
0082 }
0083 
0084 static void format_and_print_txt(FILE *outf, int level, char *header,
0085                  char *value)
0086 {
0087     char *spaces = "  ";
0088     static char delimiters[256];
0089     int i, j = 0;
0090 
0091     if (!level)
0092         return;
0093 
0094     if (level == 1) {
0095         strcpy(delimiters, " ");
0096     } else {
0097         for (i = 0; i < level - 1; ++i)
0098             j += snprintf(&delimiters[j], sizeof(delimiters) - j,
0099                       "%s", spaces);
0100     }
0101 
0102     if (header && value) {
0103         fprintf(outf, "%s", delimiters);
0104         fprintf(outf, "%s:%s\n", header, value);
0105     } else if (header) {
0106         fprintf(outf, "%s", delimiters);
0107         fprintf(outf, "%s\n", header);
0108     }
0109 }
0110 
0111 static int last_level;
0112 static void format_and_print(FILE *outf, int level, char *header, char *value)
0113 {
0114     char *spaces = "  ";
0115     static char delimiters[256];
0116     int i;
0117 
0118     if (!out_format_is_json()) {
0119         format_and_print_txt(outf, level, header, value);
0120         return;
0121     }
0122 
0123     if (level == 0) {
0124         if (header)
0125             fprintf(outf, "{");
0126         else
0127             fprintf(outf, "\n}\n");
0128 
0129     } else {
0130         int j = 0;
0131 
0132         for (i = 0; i < level; ++i)
0133             j += snprintf(&delimiters[j], sizeof(delimiters) - j,
0134                       "%s", spaces);
0135 
0136         if (last_level == level)
0137             fprintf(outf, ",\n");
0138 
0139         if (value) {
0140             if (last_level != level)
0141                 fprintf(outf, "\n");
0142 
0143             fprintf(outf, "%s\"%s\": ", delimiters, header);
0144             fprintf(outf, "\"%s\"", value);
0145         } else {
0146             for (i = last_level - 1; i >= level; --i) {
0147                 int k = 0;
0148 
0149                 for (j = i; j > 0; --j)
0150                     k += snprintf(&delimiters[k],
0151                               sizeof(delimiters) - k,
0152                               "%s", spaces);
0153                 if (i == level && header)
0154                     fprintf(outf, "\n%s},", delimiters);
0155                 else
0156                     fprintf(outf, "\n%s}", delimiters);
0157             }
0158             if (abs(last_level - level) < 3)
0159                 fprintf(outf, "\n");
0160             if (header)
0161                 fprintf(outf, "%s\"%s\": {", delimiters,
0162                     header);
0163         }
0164     }
0165 
0166     last_level = level;
0167 }
0168 
0169 static int print_package_info(int cpu, FILE *outf)
0170 {
0171     char header[256];
0172 
0173     if (out_format_is_json()) {
0174         snprintf(header, sizeof(header), "package-%d:die-%d:cpu-%d",
0175              get_physical_package_id(cpu), get_physical_die_id(cpu),
0176              cpu);
0177         format_and_print(outf, 1, header, NULL);
0178         return 1;
0179     }
0180     snprintf(header, sizeof(header), "package-%d",
0181          get_physical_package_id(cpu));
0182     format_and_print(outf, 1, header, NULL);
0183     snprintf(header, sizeof(header), "die-%d", get_physical_die_id(cpu));
0184     format_and_print(outf, 2, header, NULL);
0185     snprintf(header, sizeof(header), "cpu-%d", cpu);
0186     format_and_print(outf, 3, header, NULL);
0187 
0188     return 3;
0189 }
0190 
0191 static void _isst_pbf_display_information(int cpu, FILE *outf, int level,
0192                       struct isst_pbf_info *pbf_info,
0193                       int disp_level)
0194 {
0195     char header[256];
0196     char value[512];
0197 
0198     snprintf(header, sizeof(header), "speed-select-base-freq-properties");
0199     format_and_print(outf, disp_level, header, NULL);
0200 
0201     snprintf(header, sizeof(header), "high-priority-base-frequency(MHz)");
0202     snprintf(value, sizeof(value), "%d",
0203          pbf_info->p1_high * DISP_FREQ_MULTIPLIER);
0204     format_and_print(outf, disp_level + 1, header, value);
0205 
0206     snprintf(header, sizeof(header), "high-priority-cpu-mask");
0207     printcpumask(sizeof(value), value, pbf_info->core_cpumask_size,
0208              pbf_info->core_cpumask);
0209     format_and_print(outf, disp_level + 1, header, value);
0210 
0211     snprintf(header, sizeof(header), "high-priority-cpu-list");
0212     printcpulist(sizeof(value), value,
0213              pbf_info->core_cpumask_size,
0214              pbf_info->core_cpumask);
0215     format_and_print(outf, disp_level + 1, header, value);
0216 
0217     snprintf(header, sizeof(header), "low-priority-base-frequency(MHz)");
0218     snprintf(value, sizeof(value), "%d",
0219          pbf_info->p1_low * DISP_FREQ_MULTIPLIER);
0220     format_and_print(outf, disp_level + 1, header, value);
0221 
0222     if (is_clx_n_platform())
0223         return;
0224 
0225     snprintf(header, sizeof(header), "tjunction-temperature(C)");
0226     snprintf(value, sizeof(value), "%d", pbf_info->t_prochot);
0227     format_and_print(outf, disp_level + 1, header, value);
0228 
0229     snprintf(header, sizeof(header), "thermal-design-power(W)");
0230     snprintf(value, sizeof(value), "%d", pbf_info->tdp);
0231     format_and_print(outf, disp_level + 1, header, value);
0232 }
0233 
0234 static void _isst_fact_display_information(int cpu, FILE *outf, int level,
0235                        int fact_bucket, int fact_avx,
0236                        struct isst_fact_info *fact_info,
0237                        int base_level)
0238 {
0239     struct isst_fact_bucket_info *bucket_info = fact_info->bucket_info;
0240     char header[256];
0241     char value[256];
0242     int print = 0, j;
0243 
0244     for (j = 0; j < ISST_FACT_MAX_BUCKETS; ++j) {
0245         if (fact_bucket != 0xff && fact_bucket != j)
0246             continue;
0247 
0248         if (!bucket_info[j].high_priority_cores_count)
0249             break;
0250 
0251         print = 1;
0252     }
0253     if (!print) {
0254         fprintf(stderr, "Invalid bucket\n");
0255         return;
0256     }
0257 
0258     snprintf(header, sizeof(header), "speed-select-turbo-freq-properties");
0259     format_and_print(outf, base_level, header, NULL);
0260     for (j = 0; j < ISST_FACT_MAX_BUCKETS; ++j) {
0261         if (fact_bucket != 0xff && fact_bucket != j)
0262             continue;
0263 
0264         if (!bucket_info[j].high_priority_cores_count)
0265             break;
0266 
0267         snprintf(header, sizeof(header), "bucket-%d", j);
0268         format_and_print(outf, base_level + 1, header, NULL);
0269 
0270         snprintf(header, sizeof(header), "high-priority-cores-count");
0271         snprintf(value, sizeof(value), "%d",
0272              bucket_info[j].high_priority_cores_count);
0273         format_and_print(outf, base_level + 2, header, value);
0274 
0275         if (fact_avx & 0x01) {
0276             snprintf(header, sizeof(header),
0277                  "high-priority-max-frequency(MHz)");
0278             snprintf(value, sizeof(value), "%d",
0279                  bucket_info[j].sse_trl * DISP_FREQ_MULTIPLIER);
0280             format_and_print(outf, base_level + 2, header, value);
0281         }
0282 
0283         if (fact_avx & 0x02) {
0284             snprintf(header, sizeof(header),
0285                  "high-priority-max-avx2-frequency(MHz)");
0286             snprintf(value, sizeof(value), "%d",
0287                  bucket_info[j].avx_trl * DISP_FREQ_MULTIPLIER);
0288             format_and_print(outf, base_level + 2, header, value);
0289         }
0290 
0291         if (fact_avx & 0x04) {
0292             snprintf(header, sizeof(header),
0293                  "high-priority-max-avx512-frequency(MHz)");
0294             snprintf(value, sizeof(value), "%d",
0295                  bucket_info[j].avx512_trl *
0296                      DISP_FREQ_MULTIPLIER);
0297             format_and_print(outf, base_level + 2, header, value);
0298         }
0299     }
0300     snprintf(header, sizeof(header),
0301          "speed-select-turbo-freq-clip-frequencies");
0302     format_and_print(outf, base_level + 1, header, NULL);
0303     snprintf(header, sizeof(header), "low-priority-max-frequency(MHz)");
0304     snprintf(value, sizeof(value), "%d",
0305          fact_info->lp_clipping_ratio_license_sse *
0306              DISP_FREQ_MULTIPLIER);
0307     format_and_print(outf, base_level + 2, header, value);
0308     snprintf(header, sizeof(header),
0309          "low-priority-max-avx2-frequency(MHz)");
0310     snprintf(value, sizeof(value), "%d",
0311          fact_info->lp_clipping_ratio_license_avx2 *
0312              DISP_FREQ_MULTIPLIER);
0313     format_and_print(outf, base_level + 2, header, value);
0314     snprintf(header, sizeof(header),
0315          "low-priority-max-avx512-frequency(MHz)");
0316     snprintf(value, sizeof(value), "%d",
0317          fact_info->lp_clipping_ratio_license_avx512 *
0318              DISP_FREQ_MULTIPLIER);
0319     format_and_print(outf, base_level + 2, header, value);
0320 }
0321 
0322 void isst_ctdp_display_core_info(int cpu, FILE *outf, char *prefix,
0323                  unsigned int val, char *str0, char *str1)
0324 {
0325     char header[256];
0326     char value[256];
0327     int level = 1;
0328 
0329     if (out_format_is_json()) {
0330         snprintf(header, sizeof(header), "package-%d:die-%d:cpu-%d",
0331              get_physical_package_id(cpu), get_physical_die_id(cpu),
0332              cpu);
0333         format_and_print(outf, level++, header, NULL);
0334     } else {
0335         snprintf(header, sizeof(header), "package-%d",
0336              get_physical_package_id(cpu));
0337         format_and_print(outf, level++, header, NULL);
0338         snprintf(header, sizeof(header), "die-%d",
0339              get_physical_die_id(cpu));
0340         format_and_print(outf, level++, header, NULL);
0341         snprintf(header, sizeof(header), "cpu-%d", cpu);
0342         format_and_print(outf, level++, header, NULL);
0343     }
0344 
0345     if (str0 && !val)
0346         snprintf(value, sizeof(value), "%s", str0);
0347     else if (str1 && val)
0348         snprintf(value, sizeof(value), "%s", str1);
0349     else
0350         snprintf(value, sizeof(value), "%u", val);
0351     format_and_print(outf, level, prefix, value);
0352 
0353     format_and_print(outf, 1, NULL, NULL);
0354 }
0355 
0356 void isst_ctdp_display_information(int cpu, FILE *outf, int tdp_level,
0357                    struct isst_pkg_ctdp *pkg_dev)
0358 {
0359     char header[256];
0360     char value[512];
0361     static int level;
0362     int i;
0363 
0364     if (pkg_dev->processed)
0365         level = print_package_info(cpu, outf);
0366 
0367     for (i = 0; i <= pkg_dev->levels; ++i) {
0368         struct isst_pkg_ctdp_level_info *ctdp_level;
0369         int j;
0370 
0371         ctdp_level = &pkg_dev->ctdp_level[i];
0372         if (!ctdp_level->processed)
0373             continue;
0374 
0375         snprintf(header, sizeof(header), "perf-profile-level-%d",
0376              ctdp_level->level);
0377         format_and_print(outf, level + 1, header, NULL);
0378 
0379         snprintf(header, sizeof(header), "cpu-count");
0380         j = get_cpu_count(get_physical_die_id(cpu),
0381                   get_physical_die_id(cpu));
0382         snprintf(value, sizeof(value), "%d", j);
0383         format_and_print(outf, level + 2, header, value);
0384 
0385         j = CPU_COUNT_S(ctdp_level->core_cpumask_size,
0386                 ctdp_level->core_cpumask);
0387         if (j) {
0388             snprintf(header, sizeof(header), "enable-cpu-count");
0389             snprintf(value, sizeof(value), "%d", j);
0390             format_and_print(outf, level + 2, header, value);
0391         }
0392 
0393         if (ctdp_level->core_cpumask_size) {
0394             snprintf(header, sizeof(header), "enable-cpu-mask");
0395             printcpumask(sizeof(value), value,
0396                      ctdp_level->core_cpumask_size,
0397                      ctdp_level->core_cpumask);
0398             format_and_print(outf, level + 2, header, value);
0399 
0400             snprintf(header, sizeof(header), "enable-cpu-list");
0401             printcpulist(sizeof(value), value,
0402                      ctdp_level->core_cpumask_size,
0403                      ctdp_level->core_cpumask);
0404             format_and_print(outf, level + 2, header, value);
0405         }
0406 
0407         snprintf(header, sizeof(header), "thermal-design-power-ratio");
0408         snprintf(value, sizeof(value), "%d", ctdp_level->tdp_ratio);
0409         format_and_print(outf, level + 2, header, value);
0410 
0411         snprintf(header, sizeof(header), "base-frequency(MHz)");
0412         if (!ctdp_level->sse_p1)
0413             ctdp_level->sse_p1 = ctdp_level->tdp_ratio;
0414         snprintf(value, sizeof(value), "%d",
0415               ctdp_level->sse_p1 * DISP_FREQ_MULTIPLIER);
0416         format_and_print(outf, level + 2, header, value);
0417 
0418         if (ctdp_level->avx2_p1) {
0419             snprintf(header, sizeof(header), "base-frequency-avx2(MHz)");
0420             snprintf(value, sizeof(value), "%d",
0421                  ctdp_level->avx2_p1 * DISP_FREQ_MULTIPLIER);
0422             format_and_print(outf, level + 2, header, value);
0423         }
0424 
0425         if (ctdp_level->avx512_p1) {
0426             snprintf(header, sizeof(header), "base-frequency-avx512(MHz)");
0427             snprintf(value, sizeof(value), "%d",
0428                  ctdp_level->avx512_p1 * DISP_FREQ_MULTIPLIER);
0429             format_and_print(outf, level + 2, header, value);
0430         }
0431 
0432         if (ctdp_level->uncore_p1) {
0433             snprintf(header, sizeof(header), "uncore-frequency-min(MHz)");
0434             snprintf(value, sizeof(value), "%d",
0435                  ctdp_level->uncore_p1 * DISP_FREQ_MULTIPLIER);
0436             format_and_print(outf, level + 2, header, value);
0437         }
0438 
0439         if (ctdp_level->uncore_p0) {
0440             snprintf(header, sizeof(header), "uncore-frequency-max(MHz)");
0441             snprintf(value, sizeof(value), "%d",
0442                  ctdp_level->uncore_p0 * DISP_FREQ_MULTIPLIER);
0443             format_and_print(outf, level + 2, header, value);
0444         }
0445 
0446         if (ctdp_level->mem_freq) {
0447             snprintf(header, sizeof(header), "mem-frequency(MHz)");
0448             snprintf(value, sizeof(value), "%d",
0449                  ctdp_level->mem_freq);
0450             format_and_print(outf, level + 2, header, value);
0451         }
0452 
0453         snprintf(header, sizeof(header),
0454              "speed-select-turbo-freq");
0455         if (ctdp_level->fact_support) {
0456             if (ctdp_level->fact_enabled)
0457                 snprintf(value, sizeof(value), "enabled");
0458             else
0459                 snprintf(value, sizeof(value), "disabled");
0460         } else
0461             snprintf(value, sizeof(value), "unsupported");
0462         format_and_print(outf, level + 2, header, value);
0463 
0464         snprintf(header, sizeof(header),
0465              "speed-select-base-freq");
0466         if (ctdp_level->pbf_support) {
0467             if (ctdp_level->pbf_enabled)
0468                 snprintf(value, sizeof(value), "enabled");
0469             else
0470                 snprintf(value, sizeof(value), "disabled");
0471         } else
0472             snprintf(value, sizeof(value), "unsupported");
0473         format_and_print(outf, level + 2, header, value);
0474 
0475         snprintf(header, sizeof(header),
0476              "speed-select-core-power");
0477         if (ctdp_level->sst_cp_support) {
0478             if (ctdp_level->sst_cp_enabled)
0479                 snprintf(value, sizeof(value), "enabled");
0480             else
0481                 snprintf(value, sizeof(value), "disabled");
0482         } else
0483             snprintf(value, sizeof(value), "unsupported");
0484         format_and_print(outf, level + 2, header, value);
0485 
0486         if (is_clx_n_platform()) {
0487             if (ctdp_level->pbf_support)
0488                 _isst_pbf_display_information(cpu, outf,
0489                                   tdp_level,
0490                               &ctdp_level->pbf_info,
0491                                   level + 2);
0492             continue;
0493         }
0494 
0495         if (ctdp_level->pkg_tdp) {
0496             snprintf(header, sizeof(header), "thermal-design-power(W)");
0497             snprintf(value, sizeof(value), "%d", ctdp_level->pkg_tdp);
0498             format_and_print(outf, level + 2, header, value);
0499         }
0500 
0501         if (ctdp_level->t_proc_hot) {
0502             snprintf(header, sizeof(header), "tjunction-max(C)");
0503             snprintf(value, sizeof(value), "%d", ctdp_level->t_proc_hot);
0504             format_and_print(outf, level + 2, header, value);
0505         }
0506 
0507         snprintf(header, sizeof(header), "turbo-ratio-limits-sse");
0508         format_and_print(outf, level + 2, header, NULL);
0509         for (j = 0; j < 8; ++j) {
0510             snprintf(header, sizeof(header), "bucket-%d", j);
0511             format_and_print(outf, level + 3, header, NULL);
0512 
0513             snprintf(header, sizeof(header), "core-count");
0514             snprintf(value, sizeof(value), "%llu", (ctdp_level->buckets_info >> (j * 8)) & 0xff);
0515             format_and_print(outf, level + 4, header, value);
0516 
0517             snprintf(header, sizeof(header),
0518                 "max-turbo-frequency(MHz)");
0519             snprintf(value, sizeof(value), "%d",
0520                  ctdp_level->trl_sse_active_cores[j] *
0521                   DISP_FREQ_MULTIPLIER);
0522             format_and_print(outf, level + 4, header, value);
0523         }
0524 
0525         if (ctdp_level->trl_avx_active_cores[0]) {
0526             snprintf(header, sizeof(header), "turbo-ratio-limits-avx2");
0527             format_and_print(outf, level + 2, header, NULL);
0528             for (j = 0; j < 8; ++j) {
0529                 snprintf(header, sizeof(header), "bucket-%d", j);
0530                 format_and_print(outf, level + 3, header, NULL);
0531 
0532                 snprintf(header, sizeof(header), "core-count");
0533                 snprintf(value, sizeof(value), "%llu", (ctdp_level->buckets_info >> (j * 8)) & 0xff);
0534                 format_and_print(outf, level + 4, header, value);
0535 
0536                 snprintf(header, sizeof(header), "max-turbo-frequency(MHz)");
0537                 snprintf(value, sizeof(value), "%d", ctdp_level->trl_avx_active_cores[j] * DISP_FREQ_MULTIPLIER);
0538                 format_and_print(outf, level + 4, header, value);
0539             }
0540         }
0541 
0542         if (ctdp_level->trl_avx_512_active_cores[0]) {
0543             snprintf(header, sizeof(header), "turbo-ratio-limits-avx512");
0544             format_and_print(outf, level + 2, header, NULL);
0545             for (j = 0; j < 8; ++j) {
0546                 snprintf(header, sizeof(header), "bucket-%d", j);
0547                 format_and_print(outf, level + 3, header, NULL);
0548 
0549                 snprintf(header, sizeof(header), "core-count");
0550                 snprintf(value, sizeof(value), "%llu", (ctdp_level->buckets_info >> (j * 8)) & 0xff);
0551                 format_and_print(outf, level + 4, header, value);
0552 
0553                 snprintf(header, sizeof(header), "max-turbo-frequency(MHz)");
0554                 snprintf(value, sizeof(value), "%d", ctdp_level->trl_avx_512_active_cores[j] * DISP_FREQ_MULTIPLIER);
0555                 format_and_print(outf, level + 4, header, value);
0556             }
0557         }
0558 
0559         if (ctdp_level->pbf_support)
0560             _isst_pbf_display_information(cpu, outf, i,
0561                               &ctdp_level->pbf_info,
0562                               level + 2);
0563         if (ctdp_level->fact_support)
0564             _isst_fact_display_information(cpu, outf, i, 0xff, 0xff,
0565                                &ctdp_level->fact_info,
0566                                level + 2);
0567     }
0568 
0569     format_and_print(outf, 1, NULL, NULL);
0570 }
0571 
0572 static int start;
0573 void isst_ctdp_display_information_start(FILE *outf)
0574 {
0575     last_level = 0;
0576     format_and_print(outf, 0, "start", NULL);
0577     start = 1;
0578 }
0579 
0580 void isst_ctdp_display_information_end(FILE *outf)
0581 {
0582     format_and_print(outf, 0, NULL, NULL);
0583     start = 0;
0584 }
0585 
0586 void isst_pbf_display_information(int cpu, FILE *outf, int level,
0587                   struct isst_pbf_info *pbf_info)
0588 {
0589     int _level;
0590 
0591     _level = print_package_info(cpu, outf);
0592     _isst_pbf_display_information(cpu, outf, level, pbf_info, _level + 1);
0593     format_and_print(outf, 1, NULL, NULL);
0594 }
0595 
0596 void isst_fact_display_information(int cpu, FILE *outf, int level,
0597                    int fact_bucket, int fact_avx,
0598                    struct isst_fact_info *fact_info)
0599 {
0600     int _level;
0601 
0602     _level = print_package_info(cpu, outf);
0603     _isst_fact_display_information(cpu, outf, level, fact_bucket, fact_avx,
0604                        fact_info, _level + 1);
0605     format_and_print(outf, 1, NULL, NULL);
0606 }
0607 
0608 void isst_clos_display_information(int cpu, FILE *outf, int clos,
0609                    struct isst_clos_config *clos_config)
0610 {
0611     char header[256];
0612     char value[256];
0613     int level;
0614 
0615     level = print_package_info(cpu, outf);
0616 
0617     snprintf(header, sizeof(header), "core-power");
0618     format_and_print(outf, level + 1, header, NULL);
0619 
0620     snprintf(header, sizeof(header), "clos");
0621     snprintf(value, sizeof(value), "%d", clos);
0622     format_and_print(outf, level + 2, header, value);
0623 
0624     snprintf(header, sizeof(header), "epp");
0625     snprintf(value, sizeof(value), "%d", clos_config->epp);
0626     format_and_print(outf, level + 2, header, value);
0627 
0628     snprintf(header, sizeof(header), "clos-proportional-priority");
0629     snprintf(value, sizeof(value), "%d", clos_config->clos_prop_prio);
0630     format_and_print(outf, level + 2, header, value);
0631 
0632     snprintf(header, sizeof(header), "clos-min");
0633     snprintf(value, sizeof(value), "%d MHz", clos_config->clos_min * DISP_FREQ_MULTIPLIER);
0634     format_and_print(outf, level + 2, header, value);
0635 
0636     snprintf(header, sizeof(header), "clos-max");
0637     if (clos_config->clos_max == 0xff)
0638         snprintf(value, sizeof(value), "Max Turbo frequency");
0639     else
0640         snprintf(value, sizeof(value), "%d MHz", clos_config->clos_max * DISP_FREQ_MULTIPLIER);
0641     format_and_print(outf, level + 2, header, value);
0642 
0643     snprintf(header, sizeof(header), "clos-desired");
0644     snprintf(value, sizeof(value), "%d MHz", clos_config->clos_desired * DISP_FREQ_MULTIPLIER);
0645     format_and_print(outf, level + 2, header, value);
0646 
0647     format_and_print(outf, level, NULL, NULL);
0648 }
0649 
0650 void isst_clos_display_clos_information(int cpu, FILE *outf,
0651                     int clos_enable, int type,
0652                     int state, int cap)
0653 {
0654     char header[256];
0655     char value[256];
0656     int level;
0657 
0658     level = print_package_info(cpu, outf);
0659 
0660     snprintf(header, sizeof(header), "core-power");
0661     format_and_print(outf, level + 1, header, NULL);
0662 
0663     snprintf(header, sizeof(header), "support-status");
0664     if (cap)
0665         snprintf(value, sizeof(value), "supported");
0666     else
0667         snprintf(value, sizeof(value), "unsupported");
0668     format_and_print(outf, level + 2, header, value);
0669 
0670     snprintf(header, sizeof(header), "enable-status");
0671     if (state)
0672         snprintf(value, sizeof(value), "enabled");
0673     else
0674         snprintf(value, sizeof(value), "disabled");
0675     format_and_print(outf, level + 2, header, value);
0676 
0677     snprintf(header, sizeof(header), "clos-enable-status");
0678     if (clos_enable)
0679         snprintf(value, sizeof(value), "enabled");
0680     else
0681         snprintf(value, sizeof(value), "disabled");
0682     format_and_print(outf, level + 2, header, value);
0683 
0684     snprintf(header, sizeof(header), "priority-type");
0685     if (type)
0686         snprintf(value, sizeof(value), "ordered");
0687     else
0688         snprintf(value, sizeof(value), "proportional");
0689     format_and_print(outf, level + 2, header, value);
0690 
0691     format_and_print(outf, level, NULL, NULL);
0692 }
0693 
0694 void isst_clos_display_assoc_information(int cpu, FILE *outf, int clos)
0695 {
0696     char header[256];
0697     char value[256];
0698     int level;
0699 
0700     level = print_package_info(cpu, outf);
0701 
0702     snprintf(header, sizeof(header), "get-assoc");
0703     format_and_print(outf, level + 1, header, NULL);
0704 
0705     snprintf(header, sizeof(header), "clos");
0706     snprintf(value, sizeof(value), "%d", clos);
0707     format_and_print(outf, level + 2, header, value);
0708 
0709     format_and_print(outf, level, NULL, NULL);
0710 }
0711 
0712 void isst_display_result(int cpu, FILE *outf, char *feature, char *cmd,
0713              int result)
0714 {
0715     char header[256];
0716     char value[256];
0717     int level = 3;
0718 
0719     if (cpu >= 0)
0720         level = print_package_info(cpu, outf);
0721 
0722     snprintf(header, sizeof(header), "%s", feature);
0723     format_and_print(outf, level + 1, header, NULL);
0724     snprintf(header, sizeof(header), "%s", cmd);
0725     if (!result)
0726         snprintf(value, sizeof(value), "success");
0727     else
0728         snprintf(value, sizeof(value), "failed(error %d)", result);
0729     format_and_print(outf, level + 2, header, value);
0730 
0731     format_and_print(outf, level, NULL, NULL);
0732 }
0733 
0734 void isst_display_error_info_message(int error, char *msg, int arg_valid, int arg)
0735 {
0736     FILE *outf = get_output_file();
0737     static int error_index;
0738     char header[256];
0739     char value[256];
0740 
0741     if (!out_format_is_json()) {
0742         if (arg_valid)
0743             snprintf(value, sizeof(value), "%s %d", msg, arg);
0744         else
0745             snprintf(value, sizeof(value), "%s", msg);
0746 
0747         if (error)
0748             fprintf(outf, "Error: %s\n", value);
0749         else
0750             fprintf(outf, "Information: %s\n", value);
0751         return;
0752     }
0753 
0754     if (!start)
0755         format_and_print(outf, 0, "start", NULL);
0756 
0757     if (error)
0758         snprintf(header, sizeof(header), "Error%d", error_index++);
0759     else
0760         snprintf(header, sizeof(header), "Information:%d", error_index++);
0761     format_and_print(outf, 1, header, NULL);
0762 
0763     snprintf(header, sizeof(header), "message");
0764     if (arg_valid)
0765         snprintf(value, sizeof(value), "%s %d", msg, arg);
0766     else
0767         snprintf(value, sizeof(value), "%s", msg);
0768 
0769     format_and_print(outf, 2, header, value);
0770     format_and_print(outf, 1, NULL, NULL);
0771     if (!start)
0772         format_and_print(outf, 0, NULL, NULL);
0773 }
0774 
0775 void isst_trl_display_information(int cpu, FILE *outf, unsigned long long trl)
0776 {
0777     char header[256];
0778     char value[256];
0779     int level;
0780 
0781     level = print_package_info(cpu, outf);
0782 
0783     snprintf(header, sizeof(header), "get-trl");
0784     format_and_print(outf, level + 1, header, NULL);
0785 
0786     snprintf(header, sizeof(header), "trl");
0787     snprintf(value, sizeof(value), "0x%llx", trl);
0788     format_and_print(outf, level + 2, header, value);
0789 
0790     format_and_print(outf, level, NULL, NULL);
0791 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!