xref: /dpdk/lib/power/power_cppc_cpufreq.c (revision 3fc2ddff) 
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2021 Intel Corporation
3  * Copyright(c) 2021 Arm Limited
4  */
5 
6 #include <rte_memcpy.h>
7 #include <rte_memory.h>
8 
9 #include "power_cppc_cpufreq.h"
10 #include "power_common.h"
11 
12 /* macros used for rounding frequency to nearest 100000 */
13 #define FREQ_ROUNDING_DELTA 50000
14 #define ROUND_FREQ_TO_N_100000 100000
15 
16 /* the unit of highest_perf and nominal_perf differs on different arm platforms.
17  * For highest_perf, it maybe 300 or 3000000, both means 3.0GHz.
18  */
19 #define UNIT_DIFF 10000
20 
21 #define POWER_CONVERT_TO_DECIMAL 10
22 
23 #define POWER_GOVERNOR_USERSPACE "userspace"
24 #define POWER_SYSFILE_SETSPEED   \
25 		"/sys/devices/system/cpu/cpu%u/cpufreq/scaling_setspeed"
26 #define POWER_SYSFILE_SCALING_MAX_FREQ \
27 		"/sys/devices/system/cpu/cpu%u/cpufreq/scaling_max_freq"
28 #define POWER_SYSFILE_SCALING_MIN_FREQ  \
29 		"/sys/devices/system/cpu/cpu%u/cpufreq/scaling_min_freq"
30 #define POWER_SYSFILE_HIGHEST_PERF \
31 		"/sys/devices/system/cpu/cpu%u/acpi_cppc/highest_perf"
32 #define POWER_SYSFILE_NOMINAL_PERF \
33 		"/sys/devices/system/cpu/cpu%u/acpi_cppc/nominal_perf"
34 #define POWER_SYSFILE_SYS_MAX \
35 		"/sys/devices/system/cpu/cpu%u/cpufreq/cpuinfo_max_freq"
36 
37 #define POWER_CPPC_DRIVER "cppc-cpufreq"
38 #define BUS_FREQ     100000
39 
40 enum power_state {
41 	POWER_IDLE = 0,
42 	POWER_ONGOING,
43 	POWER_USED,
44 	POWER_UNKNOWN
45 };
46 
47 /**
48  * Power info per lcore.
49  */
50 struct cppc_power_info {
51 	unsigned int lcore_id;                   /**< Logical core id */
52 	uint32_t state;                      /**< Power in use state */
53 	FILE *f;                             /**< FD of scaling_setspeed */
54 	char governor_ori[32];               /**< Original governor name */
55 	uint32_t curr_idx;                   /**< Freq index in freqs array */
56 	uint32_t highest_perf;		     /**< system wide max freq */
57 	uint32_t nominal_perf;		     /**< system wide nominal freq */
58 	uint16_t turbo_available;            /**< Turbo Boost available */
59 	uint16_t turbo_enable;               /**< Turbo Boost enable/disable */
60 	uint32_t nb_freqs;                   /**< number of available freqs */
61 	uint32_t freqs[RTE_MAX_LCORE_FREQS]; /**< Frequency array */
62 } __rte_cache_aligned;
63 
64 static struct cppc_power_info lcore_power_info[RTE_MAX_LCORE];
65 
66 /**
67  * It is to set specific freq for specific logical core, according to the index
68  * of supported frequencies.
69  */
70 static int
71 set_freq_internal(struct cppc_power_info *pi, uint32_t idx)
72 {
73 	if (idx >= RTE_MAX_LCORE_FREQS || idx >= pi->nb_freqs) {
74 		RTE_LOG(ERR, POWER, "Invalid frequency index %u, which "
75 				"should be less than %u\n", idx, pi->nb_freqs);
76 		return -1;
77 	}
78 
79 	/* Check if it is the same as current */
80 	if (idx == pi->curr_idx)
81 		return 0;
82 
83 	POWER_DEBUG_TRACE("Frequency[%u] %u to be set for lcore %u\n",
84 			idx, pi->freqs[idx], pi->lcore_id);
85 	if (fseek(pi->f, 0, SEEK_SET) < 0) {
86 		RTE_LOG(ERR, POWER, "Fail to set file position indicator to 0 "
87 			"for setting frequency for lcore %u\n", pi->lcore_id);
88 		return -1;
89 	}
90 	if (fprintf(pi->f, "%u", pi->freqs[idx]) < 0) {
91 		RTE_LOG(ERR, POWER, "Fail to write new frequency for "
92 				"lcore %u\n", pi->lcore_id);
93 		return -1;
94 	}
95 	fflush(pi->f);
96 	pi->curr_idx = idx;
97 
98 	return 1;
99 }
100 
101 /**
102  * It is to check the current scaling governor by reading sys file, and then
103  * set it into 'userspace' if it is not by writing the sys file. The original
104  * governor will be saved for rolling back.
105  */
106 static int
107 power_set_governor_userspace(struct cppc_power_info *pi)
108 {
109 	return power_set_governor(pi->lcore_id, POWER_GOVERNOR_USERSPACE,
110 			pi->governor_ori, sizeof(pi->governor_ori));
111 }
112 
113 static int
114 power_check_turbo(struct cppc_power_info *pi)
115 {
116 	FILE *f_nom = NULL, *f_max = NULL, *f_cmax = NULL;
117 	int ret = -1;
118 	uint32_t nominal_perf = 0, highest_perf = 0, cpuinfo_max_freq = 0;
119 
120 	open_core_sysfs_file(&f_max, "r", POWER_SYSFILE_HIGHEST_PERF,
121 			pi->lcore_id);
122 	if (f_max == NULL) {
123 		RTE_LOG(ERR, POWER, "failed to open %s\n",
124 				POWER_SYSFILE_HIGHEST_PERF);
125 		goto err;
126 	}
127 
128 	open_core_sysfs_file(&f_nom, "r", POWER_SYSFILE_NOMINAL_PERF,
129 			pi->lcore_id);
130 	if (f_nom == NULL) {
131 		RTE_LOG(ERR, POWER, "failed to open %s\n",
132 				POWER_SYSFILE_NOMINAL_PERF);
133 		goto err;
134 	}
135 
136 	open_core_sysfs_file(&f_cmax, "r", POWER_SYSFILE_SYS_MAX,
137 			pi->lcore_id);
138 	if (f_cmax == NULL) {
139 		RTE_LOG(ERR, POWER, "failed to open %s\n",
140 				POWER_SYSFILE_SYS_MAX);
141 		goto err;
142 	}
143 
144 	ret = read_core_sysfs_u32(f_max, &highest_perf);
145 	if (ret < 0) {
146 		RTE_LOG(ERR, POWER, "Failed to read %s\n",
147 				POWER_SYSFILE_HIGHEST_PERF);
148 		goto err;
149 	}
150 
151 	ret = read_core_sysfs_u32(f_nom, &nominal_perf);
152 	if (ret < 0) {
153 		RTE_LOG(ERR, POWER, "Failed to read %s\n",
154 				POWER_SYSFILE_NOMINAL_PERF);
155 		goto err;
156 	}
157 
158 	ret = read_core_sysfs_u32(f_cmax, &cpuinfo_max_freq);
159 	if (ret < 0) {
160 		RTE_LOG(ERR, POWER, "Failed to read %s\n",
161 				POWER_SYSFILE_SYS_MAX);
162 		goto err;
163 	}
164 
165 	pi->highest_perf = highest_perf;
166 	pi->nominal_perf = nominal_perf;
167 
168 	if ((highest_perf > nominal_perf) && ((cpuinfo_max_freq == highest_perf)
169 			|| cpuinfo_max_freq == highest_perf * UNIT_DIFF)) {
170 		pi->turbo_available = 1;
171 		pi->turbo_enable = 1;
172 		ret = 0;
173 		POWER_DEBUG_TRACE("Lcore %u can do Turbo Boost! highest perf %u, "
174 				"nominal perf %u\n",
175 				pi->lcore_id, highest_perf, nominal_perf);
176 	} else {
177 		pi->turbo_available = 0;
178 		pi->turbo_enable = 0;
179 		POWER_DEBUG_TRACE("Lcore %u Turbo not available! highest perf %u, "
180 				"nominal perf %u\n",
181 				pi->lcore_id, highest_perf, nominal_perf);
182 	}
183 
184 err:
185 	if (f_max != NULL)
186 		fclose(f_max);
187 	if (f_nom != NULL)
188 		fclose(f_nom);
189 	if (f_cmax != NULL)
190 		fclose(f_cmax);
191 
192 	return ret;
193 }
194 
195 /**
196  * It is to get the available frequencies of the specific lcore by reading the
197  * sys file.
198  */
199 static int
200 power_get_available_freqs(struct cppc_power_info *pi)
201 {
202 	FILE *f_min = NULL, *f_max = NULL;
203 	int ret = -1;
204 	uint32_t scaling_min_freq = 0, scaling_max_freq = 0, nominal_perf = 0;
205 	uint32_t i, num_freqs = 0;
206 
207 	open_core_sysfs_file(&f_max, "r", POWER_SYSFILE_SCALING_MAX_FREQ,
208 			pi->lcore_id);
209 	if (f_max == NULL) {
210 		RTE_LOG(ERR, POWER, "failed to open %s\n",
211 				POWER_SYSFILE_SCALING_MAX_FREQ);
212 		goto out;
213 	}
214 
215 	open_core_sysfs_file(&f_min, "r", POWER_SYSFILE_SCALING_MIN_FREQ,
216 			pi->lcore_id);
217 	if (f_min == NULL) {
218 		RTE_LOG(ERR, POWER, "failed to open %s\n",
219 				POWER_SYSFILE_SCALING_MIN_FREQ);
220 		goto out;
221 	}
222 
223 	ret = read_core_sysfs_u32(f_max, &scaling_max_freq);
224 	if (ret < 0) {
225 		RTE_LOG(ERR, POWER, "Failed to read %s\n",
226 				POWER_SYSFILE_SCALING_MAX_FREQ);
227 		goto out;
228 	}
229 
230 	ret = read_core_sysfs_u32(f_min, &scaling_min_freq);
231 	if (ret < 0) {
232 		RTE_LOG(ERR, POWER, "Failed to read %s\n",
233 				POWER_SYSFILE_SCALING_MIN_FREQ);
234 		goto out;
235 	}
236 
237 	power_check_turbo(pi);
238 
239 	if (scaling_max_freq < scaling_min_freq)
240 		goto out;
241 
242 	/* If turbo is available then there is one extra freq bucket
243 	 * to store the sys max freq which value is scaling_max_freq
244 	 */
245 	nominal_perf = (pi->nominal_perf < UNIT_DIFF) ?
246 			pi->nominal_perf * UNIT_DIFF : pi->nominal_perf;
247 	num_freqs = (nominal_perf - scaling_min_freq) / BUS_FREQ + 1 +
248 		pi->turbo_available;
249 
250 	/* Generate the freq bucket array. */
251 	for (i = 0, pi->nb_freqs = 0; i < num_freqs; i++) {
252 		if ((i == 0) && pi->turbo_available)
253 			pi->freqs[pi->nb_freqs++] = scaling_max_freq;
254 		else
255 			pi->freqs[pi->nb_freqs++] =
256 			nominal_perf - (i - pi->turbo_available) * BUS_FREQ;
257 	}
258 
259 	ret = 0;
260 
261 	POWER_DEBUG_TRACE("%d frequency(s) of lcore %u are available\n",
262 			num_freqs, pi->lcore_id);
263 
264 out:
265 	if (f_min != NULL)
266 		fclose(f_min);
267 	if (f_max != NULL)
268 		fclose(f_max);
269 
270 	return ret;
271 }
272 
273 /**
274  * It is to fopen the sys file for the future setting the lcore frequency.
275  */
276 static int
277 power_init_for_setting_freq(struct cppc_power_info *pi)
278 {
279 	FILE *f = NULL;
280 	char buf[BUFSIZ];
281 	uint32_t i, freq;
282 	int ret;
283 
284 	open_core_sysfs_file(&f, "rw+", POWER_SYSFILE_SETSPEED, pi->lcore_id);
285 	if (f == NULL) {
286 		RTE_LOG(ERR, POWER, "failed to open %s\n",
287 				POWER_SYSFILE_SETSPEED);
288 		goto err;
289 	}
290 
291 	ret = read_core_sysfs_s(f, buf, sizeof(buf));
292 	if (ret < 0) {
293 		RTE_LOG(ERR, POWER, "Failed to read %s\n",
294 				POWER_SYSFILE_SETSPEED);
295 		goto err;
296 	}
297 
298 	freq = strtoul(buf, NULL, POWER_CONVERT_TO_DECIMAL);
299 
300 	/* convert the frequency to nearest 100000 value
301 	 * Ex: if freq=1396789 then freq_conv=1400000
302 	 * Ex: if freq=800030 then freq_conv=800000
303 	 */
304 	unsigned int freq_conv = 0;
305 	freq_conv = (freq + FREQ_ROUNDING_DELTA)
306 				/ ROUND_FREQ_TO_N_100000;
307 	freq_conv = freq_conv * ROUND_FREQ_TO_N_100000;
308 
309 	for (i = 0; i < pi->nb_freqs; i++) {
310 		if (freq_conv == pi->freqs[i]) {
311 			pi->curr_idx = i;
312 			pi->f = f;
313 			return 0;
314 		}
315 	}
316 
317 err:
318 	if (f != NULL)
319 		fclose(f);
320 
321 	return -1;
322 }
323 
324 int
325 power_cppc_cpufreq_check_supported(void)
326 {
327 	return cpufreq_check_scaling_driver(POWER_CPPC_DRIVER);
328 }
329 
330 int
331 power_cppc_cpufreq_init(unsigned int lcore_id)
332 {
333 	struct cppc_power_info *pi;
334 	uint32_t exp_state;
335 
336 	if (lcore_id >= RTE_MAX_LCORE) {
337 		RTE_LOG(ERR, POWER, "Lcore id %u can not exceeds %u\n",
338 				lcore_id, RTE_MAX_LCORE - 1U);
339 		return -1;
340 	}
341 
342 	pi = &lcore_power_info[lcore_id];
343 	exp_state = POWER_IDLE;
344 	/* The power in use state works as a guard variable between
345 	 * the CPU frequency control initialization and exit process.
346 	 * The ACQUIRE memory ordering here pairs with the RELEASE
347 	 * ordering below as lock to make sure the frequency operations
348 	 * in the critical section are done under the correct state.
349 	 */
350 	if (!__atomic_compare_exchange_n(&(pi->state), &exp_state,
351 					POWER_ONGOING, 0,
352 					__ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
353 		RTE_LOG(INFO, POWER, "Power management of lcore %u is "
354 				"in use\n", lcore_id);
355 		return -1;
356 	}
357 
358 	pi->lcore_id = lcore_id;
359 	/* Check and set the governor */
360 	if (power_set_governor_userspace(pi) < 0) {
361 		RTE_LOG(ERR, POWER, "Cannot set governor of lcore %u to "
362 				"userspace\n", lcore_id);
363 		goto fail;
364 	}
365 
366 	/* Get the available frequencies */
367 	if (power_get_available_freqs(pi) < 0) {
368 		RTE_LOG(ERR, POWER, "Cannot get available frequencies of "
369 				"lcore %u\n", lcore_id);
370 		goto fail;
371 	}
372 
373 	/* Init for setting lcore frequency */
374 	if (power_init_for_setting_freq(pi) < 0) {
375 		RTE_LOG(ERR, POWER, "Cannot init for setting frequency for "
376 				"lcore %u\n", lcore_id);
377 		goto fail;
378 	}
379 
380 	/* Set freq to max by default */
381 	if (power_cppc_cpufreq_freq_max(lcore_id) < 0) {
382 		RTE_LOG(ERR, POWER, "Cannot set frequency of lcore %u "
383 				"to max\n", lcore_id);
384 		goto fail;
385 	}
386 
387 	RTE_LOG(INFO, POWER, "Initialized successfully for lcore %u "
388 			"power management\n", lcore_id);
389 
390 	__atomic_store_n(&(pi->state), POWER_USED, __ATOMIC_RELEASE);
391 
392 	return 0;
393 
394 fail:
395 	__atomic_store_n(&(pi->state), POWER_UNKNOWN, __ATOMIC_RELEASE);
396 	return -1;
397 }
398 
399 /**
400  * It is to check the governor and then set the original governor back if
401  * needed by writing the sys file.
402  */
403 static int
404 power_set_governor_original(struct cppc_power_info *pi)
405 {
406 	return power_set_governor(pi->lcore_id, pi->governor_ori, NULL, 0);
407 }
408 
409 int
410 power_cppc_cpufreq_exit(unsigned int lcore_id)
411 {
412 	struct cppc_power_info *pi;
413 	uint32_t exp_state;
414 
415 	if (lcore_id >= RTE_MAX_LCORE) {
416 		RTE_LOG(ERR, POWER, "Lcore id %u can not exceeds %u\n",
417 				lcore_id, RTE_MAX_LCORE - 1U);
418 		return -1;
419 	}
420 	pi = &lcore_power_info[lcore_id];
421 	exp_state = POWER_USED;
422 	/* The power in use state works as a guard variable between
423 	 * the CPU frequency control initialization and exit process.
424 	 * The ACQUIRE memory ordering here pairs with the RELEASE
425 	 * ordering below as lock to make sure the frequency operations
426 	 * in the critical section are done under the correct state.
427 	 */
428 	if (!__atomic_compare_exchange_n(&(pi->state), &exp_state,
429 					POWER_ONGOING, 0,
430 					__ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
431 		RTE_LOG(INFO, POWER, "Power management of lcore %u is "
432 				"not used\n", lcore_id);
433 		return -1;
434 	}
435 
436 	/* Close FD of setting freq */
437 	fclose(pi->f);
438 	pi->f = NULL;
439 
440 	/* Set the governor back to the original */
441 	if (power_set_governor_original(pi) < 0) {
442 		RTE_LOG(ERR, POWER, "Cannot set the governor of %u back "
443 				"to the original\n", lcore_id);
444 		goto fail;
445 	}
446 
447 	RTE_LOG(INFO, POWER, "Power management of lcore %u has exited from "
448 			"'userspace' mode and been set back to the "
449 			"original\n", lcore_id);
450 	__atomic_store_n(&(pi->state), POWER_IDLE, __ATOMIC_RELEASE);
451 
452 	return 0;
453 
454 fail:
455 	__atomic_store_n(&(pi->state), POWER_UNKNOWN, __ATOMIC_RELEASE);
456 
457 	return -1;
458 }
459 
460 uint32_t
461 power_cppc_cpufreq_freqs(unsigned int lcore_id, uint32_t *freqs, uint32_t num)
462 {
463 	struct cppc_power_info *pi;
464 
465 	if (lcore_id >= RTE_MAX_LCORE) {
466 		RTE_LOG(ERR, POWER, "Invalid lcore ID\n");
467 		return 0;
468 	}
469 
470 	if (freqs == NULL) {
471 		RTE_LOG(ERR, POWER, "NULL buffer supplied\n");
472 		return 0;
473 	}
474 
475 	pi = &lcore_power_info[lcore_id];
476 	if (num < pi->nb_freqs) {
477 		RTE_LOG(ERR, POWER, "Buffer size is not enough\n");
478 		return 0;
479 	}
480 	rte_memcpy(freqs, pi->freqs, pi->nb_freqs * sizeof(uint32_t));
481 
482 	return pi->nb_freqs;
483 }
484 
485 uint32_t
486 power_cppc_cpufreq_get_freq(unsigned int lcore_id)
487 {
488 	if (lcore_id >= RTE_MAX_LCORE) {
489 		RTE_LOG(ERR, POWER, "Invalid lcore ID\n");
490 		return RTE_POWER_INVALID_FREQ_INDEX;
491 	}
492 
493 	return lcore_power_info[lcore_id].curr_idx;
494 }
495 
496 int
497 power_cppc_cpufreq_set_freq(unsigned int lcore_id, uint32_t index)
498 {
499 	if (lcore_id >= RTE_MAX_LCORE) {
500 		RTE_LOG(ERR, POWER, "Invalid lcore ID\n");
501 		return -1;
502 	}
503 
504 	return set_freq_internal(&(lcore_power_info[lcore_id]), index);
505 }
506 
507 int
508 power_cppc_cpufreq_freq_down(unsigned int lcore_id)
509 {
510 	struct cppc_power_info *pi;
511 
512 	if (lcore_id >= RTE_MAX_LCORE) {
513 		RTE_LOG(ERR, POWER, "Invalid lcore ID\n");
514 		return -1;
515 	}
516 
517 	pi = &lcore_power_info[lcore_id];
518 	if (pi->curr_idx + 1 == pi->nb_freqs)
519 		return 0;
520 
521 	/* Frequencies in the array are from high to low. */
522 	return set_freq_internal(pi, pi->curr_idx + 1);
523 }
524 
525 int
526 power_cppc_cpufreq_freq_up(unsigned int lcore_id)
527 {
528 	struct cppc_power_info *pi;
529 
530 	if (lcore_id >= RTE_MAX_LCORE) {
531 		RTE_LOG(ERR, POWER, "Invalid lcore ID\n");
532 		return -1;
533 	}
534 
535 	pi = &lcore_power_info[lcore_id];
536 	if (pi->curr_idx == 0 || (pi->curr_idx == 1 &&
537 		pi->turbo_available && !pi->turbo_enable))
538 		return 0;
539 
540 	/* Frequencies in the array are from high to low. */
541 	return set_freq_internal(pi, pi->curr_idx - 1);
542 }
543 
544 int
545 power_cppc_cpufreq_freq_max(unsigned int lcore_id)
546 {
547 	if (lcore_id >= RTE_MAX_LCORE) {
548 		RTE_LOG(ERR, POWER, "Invalid lcore ID\n");
549 		return -1;
550 	}
551 
552 	/* Frequencies in the array are from high to low. */
553 	if (lcore_power_info[lcore_id].turbo_available) {
554 		if (lcore_power_info[lcore_id].turbo_enable)
555 			/* Set to Turbo */
556 			return set_freq_internal(
557 				&lcore_power_info[lcore_id], 0);
558 		else
559 			/* Set to max non-turbo */
560 			return set_freq_internal(
561 				&lcore_power_info[lcore_id], 1);
562 	} else
563 		return set_freq_internal(&lcore_power_info[lcore_id], 0);
564 }
565 
566 int
567 power_cppc_cpufreq_freq_min(unsigned int lcore_id)
568 {
569 	struct cppc_power_info *pi;
570 
571 	if (lcore_id >= RTE_MAX_LCORE) {
572 		RTE_LOG(ERR, POWER, "Invalid lcore ID\n");
573 		return -1;
574 	}
575 
576 	pi = &lcore_power_info[lcore_id];
577 
578 	/* Frequencies in the array are from high to low. */
579 	return set_freq_internal(pi, pi->nb_freqs - 1);
580 }
581 
582 int
583 power_cppc_turbo_status(unsigned int lcore_id)
584 {
585 	struct cppc_power_info *pi;
586 
587 	if (lcore_id >= RTE_MAX_LCORE) {
588 		RTE_LOG(ERR, POWER, "Invalid lcore ID\n");
589 		return -1;
590 	}
591 
592 	pi = &lcore_power_info[lcore_id];
593 
594 	return pi->turbo_enable;
595 }
596 
597 int
598 power_cppc_enable_turbo(unsigned int lcore_id)
599 {
600 	struct cppc_power_info *pi;
601 
602 	if (lcore_id >= RTE_MAX_LCORE) {
603 		RTE_LOG(ERR, POWER, "Invalid lcore ID\n");
604 		return -1;
605 	}
606 
607 	pi = &lcore_power_info[lcore_id];
608 
609 	if (pi->turbo_available)
610 		pi->turbo_enable = 1;
611 	else {
612 		pi->turbo_enable = 0;
613 		RTE_LOG(ERR, POWER,
614 			"Failed to enable turbo on lcore %u\n",
615 			lcore_id);
616 		return -1;
617 	}
618 
619 	/* TODO: must set to max once enbling Turbo? Considering add condition:
620 	 * if ((pi->turbo_available) && (pi->curr_idx <= 1))
621 	 */
622 	/* Max may have changed, so call to max function */
623 	if (power_cppc_cpufreq_freq_max(lcore_id) < 0) {
624 		RTE_LOG(ERR, POWER,
625 			"Failed to set frequency of lcore %u to max\n",
626 			lcore_id);
627 		return -1;
628 	}
629 
630 	return 0;
631 }
632 
633 int
634 power_cppc_disable_turbo(unsigned int lcore_id)
635 {
636 	struct cppc_power_info *pi;
637 
638 	if (lcore_id >= RTE_MAX_LCORE) {
639 		RTE_LOG(ERR, POWER, "Invalid lcore ID\n");
640 		return -1;
641 	}
642 
643 	pi = &lcore_power_info[lcore_id];
644 
645 	pi->turbo_enable = 0;
646 
647 	if ((pi->turbo_available) && (pi->curr_idx <= 1)) {
648 		/* Try to set freq to max by default coming out of turbo */
649 		if (power_cppc_cpufreq_freq_max(lcore_id) < 0) {
650 			RTE_LOG(ERR, POWER,
651 				"Failed to set frequency of lcore %u to max\n",
652 				lcore_id);
653 			return -1;
654 		}
655 	}
656 
657 	return 0;
658 }
659 
660 int
661 power_cppc_get_capabilities(unsigned int lcore_id,
662 		struct rte_power_core_capabilities *caps)
663 {
664 	struct cppc_power_info *pi;
665 
666 	if (lcore_id >= RTE_MAX_LCORE) {
667 		RTE_LOG(ERR, POWER, "Invalid lcore ID\n");
668 		return -1;
669 	}
670 	if (caps == NULL) {
671 		RTE_LOG(ERR, POWER, "Invalid argument\n");
672 		return -1;
673 	}
674 
675 	pi = &lcore_power_info[lcore_id];
676 	caps->capabilities = 0;
677 	caps->turbo = !!(pi->turbo_available);
678 
679 	return 0;
680 }
681