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