1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Intel Speed Select -- Enumerate and control features 4 * Copyright (c) 2019 Intel Corporation. 5 */ 6 7 #include "isst.h" 8 9 static struct isst_platform_ops *isst_ops; 10 11 #define CHECK_CB(_name) \ 12 do { \ 13 if (!isst_ops || !isst_ops->_name) { \ 14 fprintf(stderr, "Invalid ops\n"); \ 15 exit(0); \ 16 } \ 17 } while (0) 18 19 int isst_set_platform_ops(int api_version) 20 { 21 switch (api_version) { 22 case 1: 23 isst_ops = mbox_get_platform_ops(); 24 break; 25 case 2: 26 case 3: 27 isst_ops = tpmi_get_platform_ops(); 28 break; 29 default: 30 isst_ops = NULL; 31 break; 32 } 33 34 if (!isst_ops) 35 return -1; 36 return 0; 37 } 38 39 void isst_update_platform_param(enum isst_platform_param param, int value) 40 { 41 CHECK_CB(update_platform_param); 42 43 isst_ops->update_platform_param(param, value); 44 } 45 46 int isst_get_disp_freq_multiplier(void) 47 { 48 CHECK_CB(get_disp_freq_multiplier); 49 return isst_ops->get_disp_freq_multiplier(); 50 } 51 52 int isst_get_trl_max_levels(void) 53 { 54 CHECK_CB(get_trl_max_levels); 55 return isst_ops->get_trl_max_levels(); 56 } 57 58 char *isst_get_trl_level_name(int level) 59 { 60 CHECK_CB(get_trl_level_name); 61 return isst_ops->get_trl_level_name(level); 62 } 63 64 int isst_is_punit_valid(struct isst_id *id) 65 { 66 CHECK_CB(is_punit_valid); 67 return isst_ops->is_punit_valid(id); 68 } 69 70 int isst_send_msr_command(unsigned int cpu, unsigned int msr, int write, 71 unsigned long long *req_resp) 72 { 73 struct isst_if_msr_cmds msr_cmds; 74 const char *pathname = "/dev/isst_interface"; 75 FILE *outf = get_output_file(); 76 int fd; 77 78 fd = open(pathname, O_RDWR); 79 if (fd < 0) 80 err(-1, "%s open failed", pathname); 81 82 msr_cmds.cmd_count = 1; 83 msr_cmds.msr_cmd[0].logical_cpu = cpu; 84 msr_cmds.msr_cmd[0].msr = msr; 85 msr_cmds.msr_cmd[0].read_write = write; 86 if (write) 87 msr_cmds.msr_cmd[0].data = *req_resp; 88 89 if (ioctl(fd, ISST_IF_MSR_COMMAND, &msr_cmds) == -1) { 90 perror("ISST_IF_MSR_COMMAND"); 91 fprintf(outf, "Error: msr_cmd cpu:%d msr:%x read_write:%d\n", 92 cpu, msr, write); 93 } else { 94 if (!write) 95 *req_resp = msr_cmds.msr_cmd[0].data; 96 97 debug_printf( 98 "msr_cmd response: cpu:%d msr:%x rd_write:%x resp:%llx %llx\n", 99 cpu, msr, write, *req_resp, msr_cmds.msr_cmd[0].data); 100 } 101 102 close(fd); 103 104 return 0; 105 } 106 107 int isst_read_pm_config(struct isst_id *id, int *cp_state, int *cp_cap) 108 { 109 CHECK_CB(read_pm_config); 110 return isst_ops->read_pm_config(id, cp_state, cp_cap); 111 } 112 113 int isst_get_ctdp_levels(struct isst_id *id, struct isst_pkg_ctdp *pkg_dev) 114 { 115 CHECK_CB(get_config_levels); 116 return isst_ops->get_config_levels(id, pkg_dev); 117 } 118 119 int isst_get_ctdp_control(struct isst_id *id, int config_index, 120 struct isst_pkg_ctdp_level_info *ctdp_level) 121 { 122 CHECK_CB(get_ctdp_control); 123 return isst_ops->get_ctdp_control(id, config_index, ctdp_level); 124 } 125 126 int isst_get_tdp_info(struct isst_id *id, int config_index, 127 struct isst_pkg_ctdp_level_info *ctdp_level) 128 { 129 CHECK_CB(get_tdp_info); 130 return isst_ops->get_tdp_info(id, config_index, ctdp_level); 131 } 132 133 int isst_get_pwr_info(struct isst_id *id, int config_index, 134 struct isst_pkg_ctdp_level_info *ctdp_level) 135 { 136 CHECK_CB(get_pwr_info); 137 return isst_ops->get_pwr_info(id, config_index, ctdp_level); 138 } 139 140 int isst_get_coremask_info(struct isst_id *id, int config_index, 141 struct isst_pkg_ctdp_level_info *ctdp_level) 142 { 143 CHECK_CB(get_coremask_info); 144 return isst_ops->get_coremask_info(id, config_index, ctdp_level); 145 } 146 147 int isst_get_get_trl_from_msr(struct isst_id *id, int *trl) 148 { 149 unsigned long long msr_trl; 150 int ret; 151 152 ret = isst_send_msr_command(id->cpu, 0x1AD, 0, &msr_trl); 153 if (ret) 154 return ret; 155 156 trl[0] = msr_trl & GENMASK(7, 0); 157 trl[1] = (msr_trl & GENMASK(15, 8)) >> 8; 158 trl[2] = (msr_trl & GENMASK(23, 16)) >> 16; 159 trl[3] = (msr_trl & GENMASK(31, 24)) >> 24; 160 trl[4] = (msr_trl & GENMASK(39, 32)) >> 32; 161 trl[5] = (msr_trl & GENMASK(47, 40)) >> 40; 162 trl[6] = (msr_trl & GENMASK(55, 48)) >> 48; 163 trl[7] = (msr_trl & GENMASK(63, 56)) >> 56; 164 165 return 0; 166 } 167 168 int isst_get_get_trl(struct isst_id *id, int level, int avx_level, int *trl) 169 { 170 CHECK_CB(get_get_trl); 171 return isst_ops->get_get_trl(id, level, avx_level, trl); 172 } 173 174 int isst_get_get_trls(struct isst_id *id, int level, struct isst_pkg_ctdp_level_info *ctdp_level) 175 { 176 CHECK_CB(get_get_trls); 177 return isst_ops->get_get_trls(id, level, ctdp_level); 178 } 179 180 int isst_get_trl_bucket_info(struct isst_id *id, int level, unsigned long long *buckets_info) 181 { 182 CHECK_CB(get_trl_bucket_info); 183 return isst_ops->get_trl_bucket_info(id, level, buckets_info); 184 } 185 186 int isst_set_tdp_level(struct isst_id *id, int tdp_level) 187 { 188 CHECK_CB(set_tdp_level); 189 return isst_ops->set_tdp_level(id, tdp_level); 190 } 191 192 int isst_get_pbf_info(struct isst_id *id, int level, struct isst_pbf_info *pbf_info) 193 { 194 struct isst_pkg_ctdp_level_info ctdp_level; 195 struct isst_pkg_ctdp pkg_dev; 196 int ret; 197 198 ret = isst_get_ctdp_levels(id, &pkg_dev); 199 if (ret) { 200 isst_display_error_info_message(1, "Failed to get number of levels", 0, 0); 201 return ret; 202 } 203 204 if (level > pkg_dev.levels) { 205 isst_display_error_info_message(1, "Invalid level", 1, level); 206 return -1; 207 } 208 209 ret = isst_get_ctdp_control(id, level, &ctdp_level); 210 if (ret) 211 return ret; 212 213 if (!ctdp_level.pbf_support) { 214 isst_display_error_info_message(1, "base-freq feature is not present at this level", 1, level); 215 return -1; 216 } 217 218 pbf_info->core_cpumask_size = alloc_cpu_set(&pbf_info->core_cpumask); 219 220 CHECK_CB(get_pbf_info); 221 return isst_ops->get_pbf_info(id, level, pbf_info); 222 } 223 224 int isst_set_pbf_fact_status(struct isst_id *id, int pbf, int enable) 225 { 226 CHECK_CB(set_pbf_fact_status); 227 return isst_ops->set_pbf_fact_status(id, pbf, enable); 228 } 229 230 231 232 int isst_get_fact_info(struct isst_id *id, int level, int fact_bucket, struct isst_fact_info *fact_info) 233 { 234 struct isst_pkg_ctdp_level_info ctdp_level; 235 struct isst_pkg_ctdp pkg_dev; 236 int ret; 237 238 ret = isst_get_ctdp_levels(id, &pkg_dev); 239 if (ret) { 240 isst_display_error_info_message(1, "Failed to get number of levels", 0, 0); 241 return ret; 242 } 243 244 if (level > pkg_dev.levels) { 245 isst_display_error_info_message(1, "Invalid level", 1, level); 246 return -1; 247 } 248 249 ret = isst_get_ctdp_control(id, level, &ctdp_level); 250 if (ret) 251 return ret; 252 253 if (!ctdp_level.fact_support) { 254 isst_display_error_info_message(1, "turbo-freq feature is not present at this level", 1, level); 255 return -1; 256 } 257 CHECK_CB(get_fact_info); 258 return isst_ops->get_fact_info(id, level, fact_bucket, fact_info); 259 } 260 261 int isst_get_trl(struct isst_id *id, unsigned long long *trl) 262 { 263 int ret; 264 265 ret = isst_send_msr_command(id->cpu, 0x1AD, 0, trl); 266 if (ret) 267 return ret; 268 269 return 0; 270 } 271 272 int isst_set_trl(struct isst_id *id, unsigned long long trl) 273 { 274 int ret; 275 276 if (!trl) 277 trl = 0xFFFFFFFFFFFFFFFFULL; 278 279 ret = isst_send_msr_command(id->cpu, 0x1AD, 1, &trl); 280 if (ret) 281 return ret; 282 283 return 0; 284 } 285 286 #define MSR_TRL_FREQ_MULTIPLIER 100 287 288 int isst_set_trl_from_current_tdp(struct isst_id *id, unsigned long long trl) 289 { 290 unsigned long long msr_trl; 291 int ret; 292 293 if (id->cpu < 0) 294 return 0; 295 296 if (trl) { 297 msr_trl = trl; 298 } else { 299 struct isst_pkg_ctdp pkg_dev; 300 int trl[8]; 301 int i; 302 303 ret = isst_get_ctdp_levels(id, &pkg_dev); 304 if (ret) 305 return ret; 306 307 ret = isst_get_get_trl(id, pkg_dev.current_level, 0, trl); 308 if (ret) 309 return ret; 310 311 msr_trl = 0; 312 for (i = 0; i < 8; ++i) { 313 unsigned long long _trl = trl[i]; 314 315 /* MSR is always in 100 MHz unit */ 316 if (isst_get_disp_freq_multiplier() == 1) 317 _trl /= MSR_TRL_FREQ_MULTIPLIER; 318 319 msr_trl |= (_trl << (i * 8)); 320 } 321 } 322 ret = isst_send_msr_command(id->cpu, 0x1AD, 1, &msr_trl); 323 if (ret) 324 return ret; 325 326 return 0; 327 } 328 329 /* Return 1 if locked */ 330 int isst_get_config_tdp_lock_status(struct isst_id *id) 331 { 332 unsigned long long tdp_control = 0; 333 int ret; 334 335 ret = isst_send_msr_command(id->cpu, 0x64b, 0, &tdp_control); 336 if (ret) 337 return ret; 338 339 ret = !!(tdp_control & BIT(31)); 340 341 return ret; 342 } 343 344 void isst_get_process_ctdp_complete(struct isst_id *id, struct isst_pkg_ctdp *pkg_dev) 345 { 346 int i; 347 348 if (!pkg_dev->processed) 349 return; 350 351 for (i = 0; i < pkg_dev->levels; ++i) { 352 struct isst_pkg_ctdp_level_info *ctdp_level; 353 354 ctdp_level = &pkg_dev->ctdp_level[i]; 355 if (ctdp_level->pbf_support) 356 free_cpu_set(ctdp_level->pbf_info.core_cpumask); 357 free_cpu_set(ctdp_level->core_cpumask); 358 } 359 } 360 361 void isst_adjust_uncore_freq(struct isst_id *id, int config_index, 362 struct isst_pkg_ctdp_level_info *ctdp_level) 363 { 364 CHECK_CB(adjust_uncore_freq); 365 return isst_ops->adjust_uncore_freq(id, config_index, ctdp_level); 366 } 367 368 int isst_get_process_ctdp(struct isst_id *id, int tdp_level, struct isst_pkg_ctdp *pkg_dev) 369 { 370 int i, ret, valid = 0; 371 372 if (pkg_dev->processed) 373 return 0; 374 375 ret = isst_get_ctdp_levels(id, pkg_dev); 376 if (ret) 377 return ret; 378 379 debug_printf("cpu: %d ctdp enable:%d current level: %d levels:%d\n", 380 id->cpu, pkg_dev->enabled, pkg_dev->current_level, 381 pkg_dev->levels); 382 383 if (tdp_level != 0xff && tdp_level > pkg_dev->levels) { 384 isst_display_error_info_message(1, "Invalid level", 0, 0); 385 return -1; 386 } 387 388 if (!pkg_dev->enabled) 389 isst_display_error_info_message(0, "perf-profile feature is not supported, just base-config level 0 is valid", 0, 0); 390 391 for (i = 0; i <= pkg_dev->levels; ++i) { 392 struct isst_pkg_ctdp_level_info *ctdp_level; 393 394 if (tdp_level != 0xff && i != tdp_level) 395 continue; 396 397 debug_printf("cpu:%d Get Information for TDP level:%d\n", id->cpu, 398 i); 399 ctdp_level = &pkg_dev->ctdp_level[i]; 400 401 ctdp_level->level = i; 402 ctdp_level->control_cpu = id->cpu; 403 ctdp_level->pkg_id = id->pkg; 404 ctdp_level->die_id = id->die; 405 406 ret = isst_get_ctdp_control(id, i, ctdp_level); 407 if (ret) 408 continue; 409 410 valid = 1; 411 pkg_dev->processed = 1; 412 ctdp_level->processed = 1; 413 414 if (ctdp_level->pbf_support) { 415 ret = isst_get_pbf_info(id, i, &ctdp_level->pbf_info); 416 if (!ret) 417 ctdp_level->pbf_found = 1; 418 } 419 420 if (ctdp_level->fact_support) { 421 ret = isst_get_fact_info(id, i, 0xff, 422 &ctdp_level->fact_info); 423 if (ret) 424 return ret; 425 } 426 427 if (!pkg_dev->enabled && is_skx_based_platform()) { 428 int freq; 429 430 freq = get_cpufreq_base_freq(id->cpu); 431 if (freq > 0) { 432 ctdp_level->sse_p1 = freq / 100000; 433 ctdp_level->tdp_ratio = ctdp_level->sse_p1; 434 } 435 436 isst_get_get_trl_from_msr(id, ctdp_level->trl_ratios[0]); 437 isst_get_trl_bucket_info(id, i, &ctdp_level->trl_cores); 438 continue; 439 } 440 441 ret = isst_get_tdp_info(id, i, ctdp_level); 442 if (ret) 443 return ret; 444 445 ret = isst_get_pwr_info(id, i, ctdp_level); 446 if (ret) 447 return ret; 448 449 ctdp_level->core_cpumask_size = 450 alloc_cpu_set(&ctdp_level->core_cpumask); 451 ret = isst_get_coremask_info(id, i, ctdp_level); 452 if (ret) 453 return ret; 454 455 ret = isst_get_trl_bucket_info(id, i, &ctdp_level->trl_cores); 456 if (ret) 457 return ret; 458 459 ret = isst_get_get_trls(id, i, ctdp_level); 460 if (ret) 461 return ret; 462 } 463 464 if (!valid) 465 isst_display_error_info_message(0, "Invalid level, Can't get TDP control information at specified levels on cpu", 1, id->cpu); 466 467 return 0; 468 } 469 470 int isst_clos_get_clos_information(struct isst_id *id, int *enable, int *type) 471 { 472 CHECK_CB(get_clos_information); 473 return isst_ops->get_clos_information(id, enable, type); 474 } 475 476 int isst_pm_qos_config(struct isst_id *id, int enable_clos, int priority_type) 477 { 478 CHECK_CB(pm_qos_config); 479 return isst_ops->pm_qos_config(id, enable_clos, priority_type); 480 } 481 482 int isst_pm_get_clos(struct isst_id *id, int clos, struct isst_clos_config *clos_config) 483 { 484 CHECK_CB(pm_get_clos); 485 return isst_ops->pm_get_clos(id, clos, clos_config); 486 } 487 488 int isst_set_clos(struct isst_id *id, int clos, struct isst_clos_config *clos_config) 489 { 490 CHECK_CB(set_clos); 491 return isst_ops->set_clos(id, clos, clos_config); 492 } 493 494 int isst_clos_get_assoc_status(struct isst_id *id, int *clos_id) 495 { 496 CHECK_CB(clos_get_assoc_status); 497 return isst_ops->clos_get_assoc_status(id, clos_id); 498 } 499 500 int isst_clos_associate(struct isst_id *id, int clos_id) 501 { 502 CHECK_CB(clos_associate); 503 return isst_ops->clos_associate(id, clos_id); 504 505 } 506