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