1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2018, The Linux Foundation. All rights reserved. 4 */ 5 6 /* 7 * In Certain QCOM SoCs like apq8096 and msm8996 that have KRYO processors, 8 * the CPU frequency subset and voltage value of each OPP varies 9 * based on the silicon variant in use. Qualcomm Process Voltage Scaling Tables 10 * defines the voltage and frequency value based on the msm-id in SMEM 11 * and speedbin blown in the efuse combination. 12 * The qcom-cpufreq-nvmem driver reads the msm-id and efuse value from the SoC 13 * to provide the OPP framework with required information. 14 * This is used to determine the voltage and frequency value for each OPP of 15 * operating-points-v2 table when it is parsed by the OPP framework. 16 */ 17 18 #include <linux/cpu.h> 19 #include <linux/err.h> 20 #include <linux/init.h> 21 #include <linux/kernel.h> 22 #include <linux/module.h> 23 #include <linux/nvmem-consumer.h> 24 #include <linux/of.h> 25 #include <linux/of_device.h> 26 #include <linux/platform_device.h> 27 #include <linux/pm_domain.h> 28 #include <linux/pm_opp.h> 29 #include <linux/slab.h> 30 #include <linux/soc/qcom/smem.h> 31 32 #define MSM_ID_SMEM 137 33 34 enum _msm_id { 35 MSM8996V3 = 0xF6ul, 36 APQ8096V3 = 0x123ul, 37 MSM8996SG = 0x131ul, 38 APQ8096SG = 0x138ul, 39 }; 40 41 enum _msm8996_version { 42 MSM8996_V3, 43 MSM8996_SG, 44 NUM_OF_MSM8996_VERSIONS, 45 }; 46 47 struct qcom_cpufreq_drv; 48 49 struct qcom_cpufreq_match_data { 50 int (*get_version)(struct device *cpu_dev, 51 struct nvmem_cell *speedbin_nvmem, 52 char **pvs_name, 53 struct qcom_cpufreq_drv *drv); 54 const char **genpd_names; 55 }; 56 57 struct qcom_cpufreq_drv { 58 int *opp_tokens; 59 u32 versions; 60 const struct qcom_cpufreq_match_data *data; 61 }; 62 63 static struct platform_device *cpufreq_dt_pdev, *cpufreq_pdev; 64 65 static void get_krait_bin_format_a(struct device *cpu_dev, 66 int *speed, int *pvs, int *pvs_ver, 67 u8 *buf) 68 { 69 u32 pte_efuse; 70 71 pte_efuse = *((u32 *)buf); 72 73 *speed = pte_efuse & 0xf; 74 if (*speed == 0xf) 75 *speed = (pte_efuse >> 4) & 0xf; 76 77 if (*speed == 0xf) { 78 *speed = 0; 79 dev_warn(cpu_dev, "Speed bin: Defaulting to %d\n", *speed); 80 } else { 81 dev_dbg(cpu_dev, "Speed bin: %d\n", *speed); 82 } 83 84 *pvs = (pte_efuse >> 10) & 0x7; 85 if (*pvs == 0x7) 86 *pvs = (pte_efuse >> 13) & 0x7; 87 88 if (*pvs == 0x7) { 89 *pvs = 0; 90 dev_warn(cpu_dev, "PVS bin: Defaulting to %d\n", *pvs); 91 } else { 92 dev_dbg(cpu_dev, "PVS bin: %d\n", *pvs); 93 } 94 } 95 96 static void get_krait_bin_format_b(struct device *cpu_dev, 97 int *speed, int *pvs, int *pvs_ver, 98 u8 *buf) 99 { 100 u32 pte_efuse, redundant_sel; 101 102 pte_efuse = *((u32 *)buf); 103 redundant_sel = (pte_efuse >> 24) & 0x7; 104 105 *pvs_ver = (pte_efuse >> 4) & 0x3; 106 107 switch (redundant_sel) { 108 case 1: 109 *pvs = ((pte_efuse >> 28) & 0x8) | ((pte_efuse >> 6) & 0x7); 110 *speed = (pte_efuse >> 27) & 0xf; 111 break; 112 case 2: 113 *pvs = (pte_efuse >> 27) & 0xf; 114 *speed = pte_efuse & 0x7; 115 break; 116 default: 117 /* 4 bits of PVS are in efuse register bits 31, 8-6. */ 118 *pvs = ((pte_efuse >> 28) & 0x8) | ((pte_efuse >> 6) & 0x7); 119 *speed = pte_efuse & 0x7; 120 } 121 122 /* Check SPEED_BIN_BLOW_STATUS */ 123 if (pte_efuse & BIT(3)) { 124 dev_dbg(cpu_dev, "Speed bin: %d\n", *speed); 125 } else { 126 dev_warn(cpu_dev, "Speed bin not set. Defaulting to 0!\n"); 127 *speed = 0; 128 } 129 130 /* Check PVS_BLOW_STATUS */ 131 pte_efuse = *(((u32 *)buf) + 1); 132 pte_efuse &= BIT(21); 133 if (pte_efuse) { 134 dev_dbg(cpu_dev, "PVS bin: %d\n", *pvs); 135 } else { 136 dev_warn(cpu_dev, "PVS bin not set. Defaulting to 0!\n"); 137 *pvs = 0; 138 } 139 140 dev_dbg(cpu_dev, "PVS version: %d\n", *pvs_ver); 141 } 142 143 static enum _msm8996_version qcom_cpufreq_get_msm_id(void) 144 { 145 size_t len; 146 u32 *msm_id; 147 enum _msm8996_version version; 148 149 msm_id = qcom_smem_get(QCOM_SMEM_HOST_ANY, MSM_ID_SMEM, &len); 150 if (IS_ERR(msm_id)) 151 return NUM_OF_MSM8996_VERSIONS; 152 153 /* The first 4 bytes are format, next to them is the actual msm-id */ 154 msm_id++; 155 156 switch ((enum _msm_id)*msm_id) { 157 case MSM8996V3: 158 case APQ8096V3: 159 version = MSM8996_V3; 160 break; 161 case MSM8996SG: 162 case APQ8096SG: 163 version = MSM8996_SG; 164 break; 165 default: 166 version = NUM_OF_MSM8996_VERSIONS; 167 } 168 169 return version; 170 } 171 172 static int qcom_cpufreq_kryo_name_version(struct device *cpu_dev, 173 struct nvmem_cell *speedbin_nvmem, 174 char **pvs_name, 175 struct qcom_cpufreq_drv *drv) 176 { 177 size_t len; 178 u8 *speedbin; 179 enum _msm8996_version msm8996_version; 180 *pvs_name = NULL; 181 182 msm8996_version = qcom_cpufreq_get_msm_id(); 183 if (NUM_OF_MSM8996_VERSIONS == msm8996_version) { 184 dev_err(cpu_dev, "Not Snapdragon 820/821!"); 185 return -ENODEV; 186 } 187 188 speedbin = nvmem_cell_read(speedbin_nvmem, &len); 189 if (IS_ERR(speedbin)) 190 return PTR_ERR(speedbin); 191 192 switch (msm8996_version) { 193 case MSM8996_V3: 194 drv->versions = 1 << (unsigned int)(*speedbin); 195 break; 196 case MSM8996_SG: 197 drv->versions = 1 << ((unsigned int)(*speedbin) + 4); 198 break; 199 default: 200 BUG(); 201 break; 202 } 203 204 kfree(speedbin); 205 return 0; 206 } 207 208 static int qcom_cpufreq_krait_name_version(struct device *cpu_dev, 209 struct nvmem_cell *speedbin_nvmem, 210 char **pvs_name, 211 struct qcom_cpufreq_drv *drv) 212 { 213 int speed = 0, pvs = 0, pvs_ver = 0; 214 u8 *speedbin; 215 size_t len; 216 int ret = 0; 217 218 speedbin = nvmem_cell_read(speedbin_nvmem, &len); 219 220 if (IS_ERR(speedbin)) 221 return PTR_ERR(speedbin); 222 223 switch (len) { 224 case 4: 225 get_krait_bin_format_a(cpu_dev, &speed, &pvs, &pvs_ver, 226 speedbin); 227 break; 228 case 8: 229 get_krait_bin_format_b(cpu_dev, &speed, &pvs, &pvs_ver, 230 speedbin); 231 break; 232 default: 233 dev_err(cpu_dev, "Unable to read nvmem data. Defaulting to 0!\n"); 234 ret = -ENODEV; 235 goto len_error; 236 } 237 238 snprintf(*pvs_name, sizeof("speedXX-pvsXX-vXX"), "speed%d-pvs%d-v%d", 239 speed, pvs, pvs_ver); 240 241 drv->versions = (1 << speed); 242 243 len_error: 244 kfree(speedbin); 245 return ret; 246 } 247 248 static const struct qcom_cpufreq_match_data match_data_kryo = { 249 .get_version = qcom_cpufreq_kryo_name_version, 250 }; 251 252 static const struct qcom_cpufreq_match_data match_data_krait = { 253 .get_version = qcom_cpufreq_krait_name_version, 254 }; 255 256 static const char *qcs404_genpd_names[] = { "cpr", NULL }; 257 258 static const struct qcom_cpufreq_match_data match_data_qcs404 = { 259 .genpd_names = qcs404_genpd_names, 260 }; 261 262 static int qcom_cpufreq_probe(struct platform_device *pdev) 263 { 264 struct qcom_cpufreq_drv *drv; 265 struct nvmem_cell *speedbin_nvmem; 266 struct device_node *np; 267 struct device *cpu_dev; 268 char pvs_name_buffer[] = "speedXX-pvsXX-vXX"; 269 char *pvs_name = pvs_name_buffer; 270 unsigned cpu; 271 const struct of_device_id *match; 272 int ret; 273 274 cpu_dev = get_cpu_device(0); 275 if (!cpu_dev) 276 return -ENODEV; 277 278 np = dev_pm_opp_of_get_opp_desc_node(cpu_dev); 279 if (!np) 280 return -ENOENT; 281 282 ret = of_device_is_compatible(np, "operating-points-v2-kryo-cpu"); 283 if (!ret) { 284 of_node_put(np); 285 return -ENOENT; 286 } 287 288 drv = kzalloc(sizeof(*drv), GFP_KERNEL); 289 if (!drv) 290 return -ENOMEM; 291 292 match = pdev->dev.platform_data; 293 drv->data = match->data; 294 if (!drv->data) { 295 ret = -ENODEV; 296 goto free_drv; 297 } 298 299 if (drv->data->get_version) { 300 speedbin_nvmem = of_nvmem_cell_get(np, NULL); 301 if (IS_ERR(speedbin_nvmem)) { 302 ret = dev_err_probe(cpu_dev, PTR_ERR(speedbin_nvmem), 303 "Could not get nvmem cell\n"); 304 goto free_drv; 305 } 306 307 ret = drv->data->get_version(cpu_dev, 308 speedbin_nvmem, &pvs_name, drv); 309 if (ret) { 310 nvmem_cell_put(speedbin_nvmem); 311 goto free_drv; 312 } 313 nvmem_cell_put(speedbin_nvmem); 314 } 315 of_node_put(np); 316 317 drv->opp_tokens = kcalloc(num_possible_cpus(), sizeof(*drv->opp_tokens), 318 GFP_KERNEL); 319 if (!drv->opp_tokens) { 320 ret = -ENOMEM; 321 goto free_drv; 322 } 323 324 for_each_possible_cpu(cpu) { 325 struct dev_pm_opp_config config = { 326 .supported_hw = NULL, 327 }; 328 329 cpu_dev = get_cpu_device(cpu); 330 if (NULL == cpu_dev) { 331 ret = -ENODEV; 332 goto free_opp; 333 } 334 335 if (drv->data->get_version) { 336 config.supported_hw = &drv->versions; 337 config.supported_hw_count = 1; 338 339 if (pvs_name) 340 config.prop_name = pvs_name; 341 } 342 343 if (drv->data->genpd_names) { 344 config.genpd_names = drv->data->genpd_names; 345 config.virt_devs = NULL; 346 } 347 348 if (config.supported_hw || config.genpd_names) { 349 drv->opp_tokens[cpu] = dev_pm_opp_set_config(cpu_dev, &config); 350 if (drv->opp_tokens[cpu] < 0) { 351 ret = drv->opp_tokens[cpu]; 352 dev_err(cpu_dev, "Failed to set OPP config\n"); 353 goto free_opp; 354 } 355 } 356 } 357 358 cpufreq_dt_pdev = platform_device_register_simple("cpufreq-dt", -1, 359 NULL, 0); 360 if (!IS_ERR(cpufreq_dt_pdev)) { 361 platform_set_drvdata(pdev, drv); 362 return 0; 363 } 364 365 ret = PTR_ERR(cpufreq_dt_pdev); 366 dev_err(cpu_dev, "Failed to register platform device\n"); 367 368 free_opp: 369 for_each_possible_cpu(cpu) 370 dev_pm_opp_clear_config(drv->opp_tokens[cpu]); 371 kfree(drv->opp_tokens); 372 free_drv: 373 kfree(drv); 374 375 return ret; 376 } 377 378 static int qcom_cpufreq_remove(struct platform_device *pdev) 379 { 380 struct qcom_cpufreq_drv *drv = platform_get_drvdata(pdev); 381 unsigned int cpu; 382 383 platform_device_unregister(cpufreq_dt_pdev); 384 385 for_each_possible_cpu(cpu) 386 dev_pm_opp_clear_config(drv->opp_tokens[cpu]); 387 388 kfree(drv->opp_tokens); 389 kfree(drv); 390 391 return 0; 392 } 393 394 static struct platform_driver qcom_cpufreq_driver = { 395 .probe = qcom_cpufreq_probe, 396 .remove = qcom_cpufreq_remove, 397 .driver = { 398 .name = "qcom-cpufreq-nvmem", 399 }, 400 }; 401 402 static const struct of_device_id qcom_cpufreq_match_list[] __initconst = { 403 { .compatible = "qcom,apq8096", .data = &match_data_kryo }, 404 { .compatible = "qcom,msm8996", .data = &match_data_kryo }, 405 { .compatible = "qcom,qcs404", .data = &match_data_qcs404 }, 406 { .compatible = "qcom,ipq8064", .data = &match_data_krait }, 407 { .compatible = "qcom,apq8064", .data = &match_data_krait }, 408 { .compatible = "qcom,msm8974", .data = &match_data_krait }, 409 { .compatible = "qcom,msm8960", .data = &match_data_krait }, 410 {}, 411 }; 412 MODULE_DEVICE_TABLE(of, qcom_cpufreq_match_list); 413 414 /* 415 * Since the driver depends on smem and nvmem drivers, which may 416 * return EPROBE_DEFER, all the real activity is done in the probe, 417 * which may be defered as well. The init here is only registering 418 * the driver and the platform device. 419 */ 420 static int __init qcom_cpufreq_init(void) 421 { 422 struct device_node *np = of_find_node_by_path("/"); 423 const struct of_device_id *match; 424 int ret; 425 426 if (!np) 427 return -ENODEV; 428 429 match = of_match_node(qcom_cpufreq_match_list, np); 430 of_node_put(np); 431 if (!match) 432 return -ENODEV; 433 434 ret = platform_driver_register(&qcom_cpufreq_driver); 435 if (unlikely(ret < 0)) 436 return ret; 437 438 cpufreq_pdev = platform_device_register_data(NULL, "qcom-cpufreq-nvmem", 439 -1, match, sizeof(*match)); 440 ret = PTR_ERR_OR_ZERO(cpufreq_pdev); 441 if (0 == ret) 442 return 0; 443 444 platform_driver_unregister(&qcom_cpufreq_driver); 445 return ret; 446 } 447 module_init(qcom_cpufreq_init); 448 449 static void __exit qcom_cpufreq_exit(void) 450 { 451 platform_device_unregister(cpufreq_pdev); 452 platform_driver_unregister(&qcom_cpufreq_driver); 453 } 454 module_exit(qcom_cpufreq_exit); 455 456 MODULE_DESCRIPTION("Qualcomm Technologies, Inc. CPUfreq driver"); 457 MODULE_LICENSE("GPL v2"); 458