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
get_krait_bin_format_a(struct device * cpu_dev,int * speed,int * pvs,int * pvs_ver,u8 * buf)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
get_krait_bin_format_b(struct device * cpu_dev,int * speed,int * pvs,int * pvs_ver,u8 * buf)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
qcom_cpufreq_get_msm_id(void)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
qcom_cpufreq_kryo_name_version(struct device * cpu_dev,struct nvmem_cell * speedbin_nvmem,char ** pvs_name,struct qcom_cpufreq_drv * drv)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
qcom_cpufreq_krait_name_version(struct device * cpu_dev,struct nvmem_cell * speedbin_nvmem,char ** pvs_name,struct qcom_cpufreq_drv * drv)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
qcom_cpufreq_probe(struct platform_device * pdev)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
qcom_cpufreq_remove(struct platform_device * pdev)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 */
qcom_cpufreq_init(void)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
qcom_cpufreq_exit(void)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
