xref: /linux/tools/power/x86/intel-speed-select/isst-display.c (revision 55d0969c451159cff86949b38c39171cab962069)
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 			if (curr_index >= str_len)
29 				break;
30 		}
31 		index = snprintf(&str[curr_index], str_len - curr_index, "%d",
32 				 i);
33 		curr_index += index;
34 		if (curr_index >= str_len)
35 			break;
36 		first = 0;
37 	}
38 }
39 
40 static void printcpumask(int str_len, char *str, int mask_size,
41 			 cpu_set_t *cpu_mask)
42 {
43 	int i, max_cpus = get_topo_max_cpus();
44 	unsigned int *mask;
45 	int size, index, curr_index;
46 
47 	size = max_cpus / (sizeof(unsigned int) * 8);
48 	if (max_cpus % (sizeof(unsigned int) * 8))
49 		size++;
50 
51 	mask = calloc(size, sizeof(unsigned int));
52 	if (!mask)
53 		return;
54 
55 	for (i = 0; i < max_cpus; ++i) {
56 		int mask_index, bit_index;
57 
58 		if (!CPU_ISSET_S(i, mask_size, cpu_mask))
59 			continue;
60 
61 		mask_index = i / (sizeof(unsigned int) * 8);
62 		bit_index = i % (sizeof(unsigned int) * 8);
63 		mask[mask_index] |= BIT(bit_index);
64 	}
65 
66 	curr_index = 0;
67 	for (i = size - 1; i >= 0; --i) {
68 		index = snprintf(&str[curr_index], str_len - curr_index, "%08x",
69 				 mask[i]);
70 		curr_index += index;
71 		if (curr_index >= str_len)
72 			break;
73 		if (i) {
74 			strncat(&str[curr_index], ",", str_len - curr_index);
75 			curr_index++;
76 		}
77 		if (curr_index >= str_len)
78 			break;
79 	}
80 
81 	free(mask);
82 }
83 
84 static void format_and_print_txt(FILE *outf, int level, char *header,
85 				 char *value)
86 {
87 	char *spaces = "  ";
88 	static char delimiters[256];
89 	int i, j = 0;
90 
91 	if (!level)
92 		return;
93 
94 	if (level == 1) {
95 		strcpy(delimiters, " ");
96 	} else {
97 		for (i = 0; i < level - 1; ++i)
98 			j += snprintf(&delimiters[j], sizeof(delimiters) - j,
99 				      "%s", spaces);
100 	}
101 
102 	if (header && value) {
103 		fprintf(outf, "%s", delimiters);
104 		fprintf(outf, "%s:%s\n", header, value);
105 	} else if (header) {
106 		fprintf(outf, "%s", delimiters);
107 		fprintf(outf, "%s\n", header);
108 	}
109 }
110 
111 static int last_level;
112 static void format_and_print(FILE *outf, int level, char *header, char *value)
113 {
114 	char *spaces = "  ";
115 	static char delimiters[256];
116 	int i;
117 
118 	if (!out_format_is_json()) {
119 		format_and_print_txt(outf, level, header, value);
120 		return;
121 	}
122 
123 	if (level == 0) {
124 		if (header)
125 			fprintf(outf, "{");
126 		else
127 			fprintf(outf, "\n}\n");
128 
129 	} else {
130 		int j = 0;
131 
132 		for (i = 0; i < level; ++i)
133 			j += snprintf(&delimiters[j], sizeof(delimiters) - j,
134 				      "%s", spaces);
135 
136 		if (last_level == level)
137 			fprintf(outf, ",\n");
138 
139 		if (value) {
140 			if (last_level != level)
141 				fprintf(outf, "\n");
142 
143 			fprintf(outf, "%s\"%s\": ", delimiters, header);
144 			fprintf(outf, "\"%s\"", value);
145 		} else {
146 			for (i = last_level - 1; i >= level; --i) {
147 				int k = 0;
148 
149 				for (j = i; j > 0; --j)
150 					k += snprintf(&delimiters[k],
151 						      sizeof(delimiters) - k,
152 						      "%s", spaces);
153 				if (i == level && header)
154 					fprintf(outf, "\n%s},", delimiters);
155 				else
156 					fprintf(outf, "\n%s}", delimiters);
157 			}
158 			if (abs(last_level - level) < 3)
159 				fprintf(outf, "\n");
160 			if (header)
161 				fprintf(outf, "%s\"%s\": {", delimiters,
162 					header);
163 		}
164 	}
165 
166 	last_level = level;
167 }
168 
169 static int print_package_info(struct isst_id *id, FILE *outf)
170 {
171 	char header[256];
172 	int level = 1;
173 
174 	if (out_format_is_json()) {
175 		if (api_version() > 1) {
176 			if (id->cpu < 0)
177 				snprintf(header, sizeof(header),
178 					 "package-%d:die-%d:powerdomain-%d:cpu-None",
179 					 id->pkg, id->die, id->punit);
180 			else
181 				snprintf(header, sizeof(header),
182 					 "package-%d:die-%d:powerdomain-%d:cpu-%d",
183 					 id->pkg, id->die, id->punit, id->cpu);
184 		} else {
185 			snprintf(header, sizeof(header), "package-%d:die-%d:cpu-%d",
186 				 id->pkg, id->die, id->cpu);
187 		}
188 		format_and_print(outf, level, header, NULL);
189 		return 1;
190 	}
191 	snprintf(header, sizeof(header), "package-%d", id->pkg);
192 	format_and_print(outf, level++, header, NULL);
193 	snprintf(header, sizeof(header), "die-%d", id->die);
194 	format_and_print(outf, level++, header, NULL);
195 	if (api_version() > 1) {
196 		snprintf(header, sizeof(header), "powerdomain-%d", id->punit);
197 		format_and_print(outf, level++, header, NULL);
198 	}
199 
200 	if (id->cpu < 0)
201 		snprintf(header, sizeof(header), "cpu-None");
202 	else
203 		snprintf(header, sizeof(header), "cpu-%d", id->cpu);
204 
205 	format_and_print(outf, level, header, NULL);
206 
207 	return level;
208 }
209 
210 static void _isst_pbf_display_information(struct isst_id *id, FILE *outf, int level,
211 					  struct isst_pbf_info *pbf_info,
212 					  int disp_level)
213 {
214 	static char header[256];
215 	static char value[1024];
216 
217 	snprintf(header, sizeof(header), "speed-select-base-freq-properties");
218 	format_and_print(outf, disp_level, header, NULL);
219 
220 	snprintf(header, sizeof(header), "high-priority-base-frequency(MHz)");
221 	snprintf(value, sizeof(value), "%d",
222 		 pbf_info->p1_high * isst_get_disp_freq_multiplier());
223 	format_and_print(outf, disp_level + 1, header, value);
224 
225 	snprintf(header, sizeof(header), "high-priority-cpu-mask");
226 	printcpumask(sizeof(value), value, pbf_info->core_cpumask_size,
227 		     pbf_info->core_cpumask);
228 	format_and_print(outf, disp_level + 1, header, value);
229 
230 	snprintf(header, sizeof(header), "high-priority-cpu-list");
231 	printcpulist(sizeof(value), value,
232 		     pbf_info->core_cpumask_size,
233 		     pbf_info->core_cpumask);
234 	format_and_print(outf, disp_level + 1, header, value);
235 
236 	snprintf(header, sizeof(header), "low-priority-base-frequency(MHz)");
237 	snprintf(value, sizeof(value), "%d",
238 		 pbf_info->p1_low * isst_get_disp_freq_multiplier());
239 	format_and_print(outf, disp_level + 1, header, value);
240 
241 	if (is_clx_n_platform())
242 		return;
243 
244 	snprintf(header, sizeof(header), "tjunction-temperature(C)");
245 	snprintf(value, sizeof(value), "%d", pbf_info->t_prochot);
246 	format_and_print(outf, disp_level + 1, header, value);
247 
248 	snprintf(header, sizeof(header), "thermal-design-power(W)");
249 	snprintf(value, sizeof(value), "%d", pbf_info->tdp);
250 	format_and_print(outf, disp_level + 1, header, value);
251 }
252 
253 static void _isst_fact_display_information(struct isst_id *id, FILE *outf, int level,
254 					   int fact_bucket, int fact_avx,
255 					   struct isst_fact_info *fact_info,
256 					   int base_level)
257 {
258 	struct isst_fact_bucket_info *bucket_info = fact_info->bucket_info;
259 	int trl_max_levels = isst_get_trl_max_levels();
260 	char header[256];
261 	char value[256];
262 	int print = 0, j;
263 
264 	for (j = 0; j < ISST_FACT_MAX_BUCKETS; ++j) {
265 		if (fact_bucket != 0xff && fact_bucket != j)
266 			continue;
267 
268 		/* core count must be valid for CPU power domain */
269 		if (!bucket_info[j].hp_cores && id->cpu >= 0)
270 			break;
271 
272 		print = 1;
273 	}
274 	if (!print) {
275 		fprintf(stderr, "Invalid bucket\n");
276 		return;
277 	}
278 
279 	snprintf(header, sizeof(header), "speed-select-turbo-freq-properties");
280 	format_and_print(outf, base_level, header, NULL);
281 	for (j = 0; j < ISST_FACT_MAX_BUCKETS; ++j) {
282 		int i;
283 
284 		if (fact_bucket != 0xff && fact_bucket != j)
285 			continue;
286 
287 		if (!bucket_info[j].hp_cores)
288 			break;
289 
290 		snprintf(header, sizeof(header), "bucket-%d", j);
291 		format_and_print(outf, base_level + 1, header, NULL);
292 
293 		snprintf(header, sizeof(header), "high-priority-cores-count");
294 		snprintf(value, sizeof(value), "%d",
295 			 bucket_info[j].hp_cores);
296 		format_and_print(outf, base_level + 2, header, value);
297 		for (i = 0; i < trl_max_levels; i++) {
298 			if (!bucket_info[j].hp_ratios[i] || (fact_avx != 0xFF && !(fact_avx & (1 << i))))
299 				continue;
300 			if (i == 0 && api_version() == 1 && !is_emr_platform())
301 				snprintf(header, sizeof(header),
302 					"high-priority-max-frequency(MHz)");
303 			else
304 				snprintf(header, sizeof(header),
305 					"high-priority-max-%s-frequency(MHz)", isst_get_trl_level_name(i));
306 			snprintf(value, sizeof(value), "%d",
307 				bucket_info[j].hp_ratios[i] * isst_get_disp_freq_multiplier());
308 			format_and_print(outf, base_level + 2, header, value);
309 		}
310 	}
311 	snprintf(header, sizeof(header),
312 		 "speed-select-turbo-freq-clip-frequencies");
313 	format_and_print(outf, base_level + 1, header, NULL);
314 
315 	for (j = 0; j < trl_max_levels; j++) {
316 		if (!fact_info->lp_ratios[j])
317 			continue;
318 
319 		/* No AVX level name for SSE to be consistent with previous formatting */
320 		if (j == 0 && api_version() == 1 && !is_emr_platform())
321 			snprintf(header, sizeof(header), "low-priority-max-frequency(MHz)");
322 		else
323 			snprintf(header, sizeof(header), "low-priority-max-%s-frequency(MHz)",
324 				isst_get_trl_level_name(j));
325 		snprintf(value, sizeof(value), "%d",
326 			 fact_info->lp_ratios[j] * isst_get_disp_freq_multiplier());
327 		format_and_print(outf, base_level + 2, header, value);
328 	}
329 }
330 
331 void isst_ctdp_display_core_info(struct isst_id *id, FILE *outf, char *prefix,
332 				 unsigned int val, char *str0, char *str1)
333 {
334 	char value[256];
335 	int level = print_package_info(id, outf);
336 
337 	level++;
338 
339 	if (str0 && !val)
340 		snprintf(value, sizeof(value), "%s", str0);
341 	else if (str1 && val)
342 		snprintf(value, sizeof(value), "%s", str1);
343 	else
344 		snprintf(value, sizeof(value), "%u", val);
345 	format_and_print(outf, level, prefix, value);
346 
347 	format_and_print(outf, 1, NULL, NULL);
348 }
349 
350 void isst_ctdp_display_information(struct isst_id *id, FILE *outf, int tdp_level,
351 				   struct isst_pkg_ctdp *pkg_dev)
352 {
353 	static char header[256];
354 	static char value[1024];
355 	static int level;
356 	int trl_max_levels = isst_get_trl_max_levels();
357 	int i;
358 
359 	if (pkg_dev->processed)
360 		level = print_package_info(id, outf);
361 
362 	for (i = 0; i <= pkg_dev->levels; ++i) {
363 		struct isst_pkg_ctdp_level_info *ctdp_level;
364 		int j, k;
365 
366 		ctdp_level = &pkg_dev->ctdp_level[i];
367 		if (!ctdp_level->processed)
368 			continue;
369 
370 		snprintf(header, sizeof(header), "perf-profile-level-%d",
371 			 ctdp_level->level);
372 		format_and_print(outf, level + 1, header, NULL);
373 
374 		if (id->cpu >= 0) {
375 			snprintf(header, sizeof(header), "cpu-count");
376 			j = get_cpu_count(id);
377 			snprintf(value, sizeof(value), "%d", j);
378 			format_and_print(outf, level + 2, header, value);
379 
380 			j = CPU_COUNT_S(ctdp_level->core_cpumask_size,
381 					ctdp_level->core_cpumask);
382 			if (j) {
383 				snprintf(header, sizeof(header), "enable-cpu-count");
384 				snprintf(value, sizeof(value), "%d", j);
385 				format_and_print(outf, level + 2, header, value);
386 			}
387 
388 			if (ctdp_level->core_cpumask_size) {
389 				snprintf(header, sizeof(header), "enable-cpu-mask");
390 				printcpumask(sizeof(value), value,
391 					     ctdp_level->core_cpumask_size,
392 					     ctdp_level->core_cpumask);
393 				format_and_print(outf, level + 2, header, value);
394 
395 				snprintf(header, sizeof(header), "enable-cpu-list");
396 				printcpulist(sizeof(value), value,
397 					     ctdp_level->core_cpumask_size,
398 					     ctdp_level->core_cpumask);
399 				format_and_print(outf, level + 2, header, value);
400 			}
401 		}
402 
403 		snprintf(header, sizeof(header), "thermal-design-power-ratio");
404 		snprintf(value, sizeof(value), "%d", ctdp_level->tdp_ratio);
405 		format_and_print(outf, level + 2, header, value);
406 
407 		snprintf(header, sizeof(header), "base-frequency(MHz)");
408 		if (!ctdp_level->sse_p1)
409 			ctdp_level->sse_p1 = ctdp_level->tdp_ratio;
410 		snprintf(value, sizeof(value), "%d",
411 			  ctdp_level->sse_p1 * isst_get_disp_freq_multiplier());
412 		format_and_print(outf, level + 2, header, value);
413 
414 		if (ctdp_level->avx2_p1) {
415 			snprintf(header, sizeof(header), "base-frequency-avx2(MHz)");
416 			snprintf(value, sizeof(value), "%d",
417 				 ctdp_level->avx2_p1 * isst_get_disp_freq_multiplier());
418 			format_and_print(outf, level + 2, header, value);
419 		}
420 
421 		if (ctdp_level->avx512_p1) {
422 			snprintf(header, sizeof(header), "base-frequency-avx512(MHz)");
423 			snprintf(value, sizeof(value), "%d",
424 				 ctdp_level->avx512_p1 * isst_get_disp_freq_multiplier());
425 			format_and_print(outf, level + 2, header, value);
426 		}
427 
428 		if (ctdp_level->uncore_pm) {
429 			snprintf(header, sizeof(header), "uncore-frequency-min(MHz)");
430 			snprintf(value, sizeof(value), "%d",
431 				 ctdp_level->uncore_pm * isst_get_disp_freq_multiplier());
432 			format_and_print(outf, level + 2, header, value);
433 		}
434 
435 		if (ctdp_level->uncore_p0) {
436 			snprintf(header, sizeof(header), "uncore-frequency-max(MHz)");
437 			snprintf(value, sizeof(value), "%d",
438 				 ctdp_level->uncore_p0 * isst_get_disp_freq_multiplier());
439 			format_and_print(outf, level + 2, header, value);
440 		}
441 
442 		if (ctdp_level->amx_p1) {
443 			snprintf(header, sizeof(header), "base-frequency-amx(MHz)");
444 			snprintf(value, sizeof(value), "%d",
445 			ctdp_level->amx_p1 * isst_get_disp_freq_multiplier());
446 			format_and_print(outf, level + 2, header, value);
447 		}
448 
449 		if (ctdp_level->uncore_p1) {
450 			snprintf(header, sizeof(header), "uncore-frequency-base(MHz)");
451 			snprintf(value, sizeof(value), "%d",
452 				 ctdp_level->uncore_p1 * isst_get_disp_freq_multiplier());
453 			format_and_print(outf, level + 2, header, value);
454 		}
455 
456 		if (ctdp_level->mem_freq) {
457 			snprintf(header, sizeof(header), "max-mem-frequency(MHz)");
458 			snprintf(value, sizeof(value), "%d",
459 				 ctdp_level->mem_freq);
460 			format_and_print(outf, level + 2, header, value);
461 		}
462 
463 		if (api_version() > 1) {
464 			snprintf(header, sizeof(header), "cooling_type");
465 			snprintf(value, sizeof(value), "%d",
466 				ctdp_level->cooling_type);
467 			format_and_print(outf, level + 2, header, value);
468 		}
469 
470 		snprintf(header, sizeof(header),
471 			 "speed-select-turbo-freq");
472 		if (ctdp_level->fact_support) {
473 			if (ctdp_level->fact_enabled)
474 				snprintf(value, sizeof(value), "enabled");
475 			else
476 				snprintf(value, sizeof(value), "disabled");
477 		} else
478 			snprintf(value, sizeof(value), "unsupported");
479 		format_and_print(outf, level + 2, header, value);
480 
481 		snprintf(header, sizeof(header),
482 			 "speed-select-base-freq");
483 		if (ctdp_level->pbf_support) {
484 			if (ctdp_level->pbf_enabled)
485 				snprintf(value, sizeof(value), "enabled");
486 			else
487 				snprintf(value, sizeof(value), "disabled");
488 		} else
489 			snprintf(value, sizeof(value), "unsupported");
490 		format_and_print(outf, level + 2, header, value);
491 
492 		snprintf(header, sizeof(header),
493 			 "speed-select-core-power");
494 		if (ctdp_level->sst_cp_support) {
495 			if (ctdp_level->sst_cp_enabled)
496 				snprintf(value, sizeof(value), "enabled");
497 			else
498 				snprintf(value, sizeof(value), "disabled");
499 		} else
500 			snprintf(value, sizeof(value), "unsupported");
501 		format_and_print(outf, level + 2, header, value);
502 
503 		if (is_clx_n_platform()) {
504 			if (ctdp_level->pbf_support)
505 				_isst_pbf_display_information(id, outf,
506 							      tdp_level,
507 							  &ctdp_level->pbf_info,
508 							      level + 2);
509 			continue;
510 		}
511 
512 		if (ctdp_level->pkg_tdp) {
513 			snprintf(header, sizeof(header), "thermal-design-power(W)");
514 			snprintf(value, sizeof(value), "%d", ctdp_level->pkg_tdp);
515 			format_and_print(outf, level + 2, header, value);
516 		}
517 
518 		if (ctdp_level->t_proc_hot) {
519 			snprintf(header, sizeof(header), "tjunction-max(C)");
520 			snprintf(value, sizeof(value), "%d", ctdp_level->t_proc_hot);
521 			format_and_print(outf, level + 2, header, value);
522 		}
523 
524 		for (k = 0; k < trl_max_levels; k++) {
525 			if (!ctdp_level->trl_ratios[k][0])
526 				continue;
527 
528 			snprintf(header, sizeof(header), "turbo-ratio-limits-%s", isst_get_trl_level_name(k));
529 			format_and_print(outf, level + 2, header, NULL);
530 
531 			for (j = 0; j < 8; ++j) {
532 				snprintf(header, sizeof(header), "bucket-%d", j);
533 				format_and_print(outf, level + 3, header, NULL);
534 
535 				snprintf(header, sizeof(header), "core-count");
536 
537 				snprintf(value, sizeof(value), "%llu", (ctdp_level->trl_cores >> (j * 8)) & 0xff);
538 				format_and_print(outf, level + 4, header, value);
539 
540 				snprintf(header, sizeof(header), "max-turbo-frequency(MHz)");
541 				snprintf(value, sizeof(value), "%d", ctdp_level->trl_ratios[k][j] * isst_get_disp_freq_multiplier());
542 				format_and_print(outf, level + 4, header, value);
543 			}
544 		}
545 
546 		if (ctdp_level->pbf_support)
547 			_isst_pbf_display_information(id, outf, i,
548 						      &ctdp_level->pbf_info,
549 						      level + 2);
550 		if (ctdp_level->fact_support)
551 			_isst_fact_display_information(id, outf, i, 0xff, 0xff,
552 						       &ctdp_level->fact_info,
553 						       level + 2);
554 	}
555 
556 	format_and_print(outf, 1, NULL, NULL);
557 }
558 
559 static int start;
560 void isst_ctdp_display_information_start(FILE *outf)
561 {
562 	last_level = 0;
563 	format_and_print(outf, 0, "start", NULL);
564 	start = 1;
565 }
566 
567 void isst_ctdp_display_information_end(FILE *outf)
568 {
569 	format_and_print(outf, 0, NULL, NULL);
570 	start = 0;
571 }
572 
573 void isst_pbf_display_information(struct isst_id *id, FILE *outf, int level,
574 				  struct isst_pbf_info *pbf_info)
575 {
576 	int _level;
577 
578 	_level = print_package_info(id, outf);
579 	_isst_pbf_display_information(id, outf, level, pbf_info, _level + 1);
580 	format_and_print(outf, 1, NULL, NULL);
581 }
582 
583 void isst_fact_display_information(struct isst_id *id, FILE *outf, int level,
584 				   int fact_bucket, int fact_avx,
585 				   struct isst_fact_info *fact_info)
586 {
587 	int _level;
588 
589 	_level = print_package_info(id, outf);
590 	_isst_fact_display_information(id, outf, level, fact_bucket, fact_avx,
591 				       fact_info, _level + 1);
592 	format_and_print(outf, 1, NULL, NULL);
593 }
594 
595 void isst_clos_display_information(struct isst_id *id, FILE *outf, int clos,
596 				   struct isst_clos_config *clos_config)
597 {
598 	char header[256];
599 	char value[256];
600 	int level;
601 
602 	level = print_package_info(id, outf);
603 
604 	snprintf(header, sizeof(header), "core-power");
605 	format_and_print(outf, level + 1, header, NULL);
606 
607 	snprintf(header, sizeof(header), "clos");
608 	snprintf(value, sizeof(value), "%d", clos);
609 	format_and_print(outf, level + 2, header, value);
610 
611 	snprintf(header, sizeof(header), "epp");
612 	snprintf(value, sizeof(value), "%d", clos_config->epp);
613 	format_and_print(outf, level + 2, header, value);
614 
615 	snprintf(header, sizeof(header), "clos-proportional-priority");
616 	snprintf(value, sizeof(value), "%d", clos_config->clos_prop_prio);
617 	format_and_print(outf, level + 2, header, value);
618 
619 	snprintf(header, sizeof(header), "clos-min");
620 	snprintf(value, sizeof(value), "%d MHz", clos_config->clos_min * isst_get_disp_freq_multiplier());
621 	format_and_print(outf, level + 2, header, value);
622 
623 	snprintf(header, sizeof(header), "clos-max");
624 	if ((clos_config->clos_max * isst_get_disp_freq_multiplier()) == 25500)
625 		snprintf(value, sizeof(value), "Max Turbo frequency");
626 	else
627 		snprintf(value, sizeof(value), "%d MHz", clos_config->clos_max * isst_get_disp_freq_multiplier());
628 	format_and_print(outf, level + 2, header, value);
629 
630 	snprintf(header, sizeof(header), "clos-desired");
631 	snprintf(value, sizeof(value), "%d MHz", clos_config->clos_desired * isst_get_disp_freq_multiplier());
632 	format_and_print(outf, level + 2, header, value);
633 
634 	format_and_print(outf, level, NULL, NULL);
635 }
636 
637 void isst_clos_display_clos_information(struct isst_id *id, FILE *outf,
638 					int clos_enable, int type,
639 					int state, int cap)
640 {
641 	char header[256];
642 	char value[256];
643 	int level;
644 
645 	level = print_package_info(id, outf);
646 
647 	snprintf(header, sizeof(header), "core-power");
648 	format_and_print(outf, level + 1, header, NULL);
649 
650 	snprintf(header, sizeof(header), "support-status");
651 	if (cap)
652 		snprintf(value, sizeof(value), "supported");
653 	else
654 		snprintf(value, sizeof(value), "unsupported");
655 	format_and_print(outf, level + 2, header, value);
656 
657 	snprintf(header, sizeof(header), "enable-status");
658 	if (state)
659 		snprintf(value, sizeof(value), "enabled");
660 	else
661 		snprintf(value, sizeof(value), "disabled");
662 	format_and_print(outf, level + 2, header, value);
663 
664 	snprintf(header, sizeof(header), "clos-enable-status");
665 	if (clos_enable)
666 		snprintf(value, sizeof(value), "enabled");
667 	else
668 		snprintf(value, sizeof(value), "disabled");
669 	format_and_print(outf, level + 2, header, value);
670 
671 	snprintf(header, sizeof(header), "priority-type");
672 	if (type)
673 		snprintf(value, sizeof(value), "ordered");
674 	else
675 		snprintf(value, sizeof(value), "proportional");
676 	format_and_print(outf, level + 2, header, value);
677 
678 	format_and_print(outf, level, NULL, NULL);
679 }
680 
681 void isst_clos_display_assoc_information(struct isst_id *id, FILE *outf, int clos)
682 {
683 	char header[256];
684 	char value[256];
685 	int level;
686 
687 	level = print_package_info(id, outf);
688 
689 	snprintf(header, sizeof(header), "get-assoc");
690 	format_and_print(outf, level + 1, header, NULL);
691 
692 	snprintf(header, sizeof(header), "clos");
693 	snprintf(value, sizeof(value), "%d", clos);
694 	format_and_print(outf, level + 2, header, value);
695 
696 	format_and_print(outf, level, NULL, NULL);
697 }
698 
699 void isst_display_result(struct isst_id *id, FILE *outf, char *feature, char *cmd,
700 			 int result)
701 {
702 	char header[256];
703 	char value[256];
704 	int level = 3;
705 
706 	level = print_package_info(id, outf);
707 
708 	snprintf(header, sizeof(header), "%s", feature);
709 	format_and_print(outf, level + 1, header, NULL);
710 	snprintf(header, sizeof(header), "%s", cmd);
711 	if (!result)
712 		snprintf(value, sizeof(value), "success");
713 	else
714 		snprintf(value, sizeof(value), "failed(error %d)", result);
715 	format_and_print(outf, level + 2, header, value);
716 
717 	format_and_print(outf, level, NULL, NULL);
718 }
719 
720 void isst_display_error_info_message(int error, char *msg, int arg_valid, int arg)
721 {
722 	FILE *outf = get_output_file();
723 	static int error_index;
724 	char header[256];
725 	char value[256];
726 
727 	if (!out_format_is_json()) {
728 		if (arg_valid)
729 			snprintf(value, sizeof(value), "%s %d", msg, arg);
730 		else
731 			snprintf(value, sizeof(value), "%s", msg);
732 
733 		if (error)
734 			fprintf(outf, "Error: %s\n", value);
735 		else
736 			fprintf(outf, "Information: %s\n", value);
737 		return;
738 	}
739 
740 	if (!start)
741 		format_and_print(outf, 0, "start", NULL);
742 
743 	if (error)
744 		snprintf(header, sizeof(header), "Error%d", error_index++);
745 	else
746 		snprintf(header, sizeof(header), "Information:%d", error_index++);
747 	format_and_print(outf, 1, header, NULL);
748 
749 	snprintf(header, sizeof(header), "message");
750 	if (arg_valid)
751 		snprintf(value, sizeof(value), "%s %d", msg, arg);
752 	else
753 		snprintf(value, sizeof(value), "%s", msg);
754 
755 	format_and_print(outf, 2, header, value);
756 	format_and_print(outf, 1, NULL, NULL);
757 	if (!start)
758 		format_and_print(outf, 0, NULL, NULL);
759 }
760 
761 void isst_trl_display_information(struct isst_id *id, FILE *outf, unsigned long long trl)
762 {
763 	char header[256];
764 	char value[256];
765 	int level;
766 
767 	level = print_package_info(id, outf);
768 
769 	snprintf(header, sizeof(header), "get-trl");
770 	format_and_print(outf, level + 1, header, NULL);
771 
772 	snprintf(header, sizeof(header), "trl");
773 	snprintf(value, sizeof(value), "0x%llx", trl);
774 	format_and_print(outf, level + 2, header, value);
775 
776 	format_and_print(outf, level, NULL, NULL);
777 }
778