From: Ansuel Smith Date: Sun, 15 Dec 2019 01:28:46 +0000 (+0100) Subject: ipq806x: backport qcom-cpufreq-kryo patch X-Git-Url: http://git.lede-project.org./?a=commitdiff_plain;h=a37f787162ee2279d8b3896b3a9146369131c27a;p=openwrt%2Fstaging%2Fluka.git ipq806x: backport qcom-cpufreq-kryo patch Backport patch applied to qcom-cpufreq-kryo driver as krait cpu will base on this driver. Tested-by: Stefan Lippers-Hollmann [nbg6817/ipq8065] Signed-off-by: Ansuel Smith --- diff --git a/target/linux/ipq806x/patches-4.19/0035-qcom-cpufreq-nvmem-qcm-kyrp_make_Some_variables_static.patch b/target/linux/ipq806x/patches-4.19/0035-qcom-cpufreq-nvmem-qcm-kyrp_make_Some_variables_static.patch new file mode 100644 index 0000000000..d445c0e190 --- /dev/null +++ b/target/linux/ipq806x/patches-4.19/0035-qcom-cpufreq-nvmem-qcm-kyrp_make_Some_variables_static.patch @@ -0,0 +1,27 @@ +From 50c0b12f098fb3cfac7abcc0f2b5409f6bac5fa2 Mon Sep 17 00:00:00 2001 +From: Yangtao Li +Date: Mon, 4 Feb 2019 01:13:10 -0500 +Subject: [PATCH] cpufreq: qcom-kryo: make some variables static + +The variables are local to the source and do not +need to be in global scope, so make them static. + +Signed-off-by: Yangtao Li +Signed-off-by: Viresh Kumar +--- + drivers/cpufreq/qcom-cpufreq-kryo.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/drivers/cpufreq/qcom-cpufreq-kryo.c b/drivers/cpufreq/qcom-cpufreq-kryo.c +index 2a3675c24032b..1c8583cc06a2a 100644 +--- a/drivers/cpufreq/qcom-cpufreq-kryo.c ++++ b/drivers/cpufreq/qcom-cpufreq-kryo.c +@@ -42,7 +42,7 @@ enum _msm8996_version { + NUM_OF_MSM8996_VERSIONS, + }; + +-struct platform_device *cpufreq_dt_pdev, *kryo_cpufreq_pdev; ++static struct platform_device *cpufreq_dt_pdev, *kryo_cpufreq_pdev; + + static enum _msm8996_version qcom_cpufreq_kryo_get_msm_id(void) + { diff --git a/target/linux/ipq806x/patches-4.19/0036-qcom-cpufreq-nvmem-Re-organise-kryo-cpufreq-driver.patch b/target/linux/ipq806x/patches-4.19/0036-qcom-cpufreq-nvmem-Re-organise-kryo-cpufreq-driver.patch new file mode 100644 index 0000000000..ab6a37ba37 --- /dev/null +++ b/target/linux/ipq806x/patches-4.19/0036-qcom-cpufreq-nvmem-Re-organise-kryo-cpufreq-driver.patch @@ -0,0 +1,281 @@ +From 7d12709544b8b3fb9727a34a664b8380e1e3493a Mon Sep 17 00:00:00 2001 +From: Sricharan R +Date: Thu, 25 Jul 2019 12:41:31 +0200 +Subject: [PATCH] cpufreq: qcom: Re-organise kryo cpufreq to use it for other + nvmem based qcom socs + +The kryo cpufreq driver reads the nvmem cell and uses that data to +populate the opps. There are other qcom cpufreq socs like krait which +does similar thing. Except for the interpretation of the read data, +rest of the driver is same for both the cases. So pull the common things +out for reuse. + +Signed-off-by: Sricharan R +[niklas.cassel@linaro.org: split dt-binding into a separate patch and +do not rename the compatible string. Update MAINTAINERS file.] +Signed-off-by: Niklas Cassel +Reviewed-by: Ilia Lin +Reviewed-by: Stephen Boyd +Signed-off-by: Viresh Kumar +--- + MAINTAINERS | 4 +- + drivers/cpufreq/Kconfig.arm | 4 +- + drivers/cpufreq/Makefile | 2 +- + ...om-cpufreq-kryo.c => qcom-cpufreq-nvmem.c} | 122 +++++++++++------- + 4 files changed, 78 insertions(+), 54 deletions(-) + rename drivers/cpufreq/{qcom-cpufreq-kryo.c => qcom-cpufreq-nvmem.c} (69%) + +diff --git a/drivers/cpufreq/Kconfig.arm b/drivers/cpufreq/Kconfig.arm +index 56c31a78c6920..b1aa485a28dde 100644 +--- a/drivers/cpufreq/Kconfig.arm ++++ b/drivers/cpufreq/Kconfig.arm +@@ -120,8 +120,8 @@ config ARM_OMAP2PLUS_CPUFREQ + depends on ARCH_OMAP2PLUS + default ARCH_OMAP2PLUS + +-config ARM_QCOM_CPUFREQ_KRYO +- tristate "Qualcomm Kryo based CPUFreq" ++config ARM_QCOM_CPUFREQ_NVMEM ++ tristate "Qualcomm nvmem based CPUFreq" + depends on ARM64 + depends on QCOM_QFPROM + depends on QCOM_SMEM +diff --git a/drivers/cpufreq/Makefile b/drivers/cpufreq/Makefile +index 5a6c70d26c985..8572a918aa755 100644 +--- a/drivers/cpufreq/Makefile ++++ b/drivers/cpufreq/Makefile +@@ -64,7 +64,7 @@ obj-$(CONFIG_MACH_MVEBU_V7) += mvebu-cpufreq.o + obj-$(CONFIG_ARM_OMAP2PLUS_CPUFREQ) += omap-cpufreq.o + obj-$(CONFIG_ARM_PXA2xx_CPUFREQ) += pxa2xx-cpufreq.o + obj-$(CONFIG_PXA3xx) += pxa3xx-cpufreq.o +-obj-$(CONFIG_ARM_QCOM_CPUFREQ_KRYO) += qcom-cpufreq-kryo.o ++obj-$(CONFIG_ARM_QCOM_CPUFREQ_NVMEM) += qcom-cpufreq-nvmem.o + obj-$(CONFIG_ARM_S3C2410_CPUFREQ) += s3c2410-cpufreq.o + obj-$(CONFIG_ARM_S3C2412_CPUFREQ) += s3c2412-cpufreq.o + obj-$(CONFIG_ARM_S3C2416_CPUFREQ) += s3c2416-cpufreq.o +diff --git a/drivers/cpufreq/qcom-cpufreq-kryo.c b/drivers/cpufreq/qcom-cpufreq-nvmem.c +similarity index 69% +rename from drivers/cpufreq/qcom-cpufreq-kryo.c +rename to drivers/cpufreq/qcom-cpufreq-nvmem.c +index dd64dcf89c74c..fd08120768af2 100644 +--- a/drivers/cpufreq/qcom-cpufreq-kryo.c ++++ b/drivers/cpufreq/qcom-cpufreq-nvmem.c +@@ -9,7 +9,7 @@ + * based on the silicon variant in use. Qualcomm Process Voltage Scaling Tables + * defines the voltage and frequency value based on the msm-id in SMEM + * and speedbin blown in the efuse combination. +- * The qcom-cpufreq-kryo driver reads the msm-id and efuse value from the SoC ++ * The qcom-cpufreq-nvmem driver reads the msm-id and efuse value from the SoC + * to provide the OPP framework with required information. + * This is used to determine the voltage and frequency value for each OPP of + * operating-points-v2 table when it is parsed by the OPP framework. +@@ -22,6 +22,7 @@ + #include + #include + #include ++#include + #include + #include + #include +@@ -42,9 +43,9 @@ enum _msm8996_version { + NUM_OF_MSM8996_VERSIONS, + }; + +-static struct platform_device *cpufreq_dt_pdev, *kryo_cpufreq_pdev; ++static struct platform_device *cpufreq_dt_pdev, *cpufreq_pdev; + +-static enum _msm8996_version qcom_cpufreq_kryo_get_msm_id(void) ++static enum _msm8996_version qcom_cpufreq_get_msm_id(void) + { + size_t len; + u32 *msm_id; +@@ -73,28 +74,62 @@ static enum _msm8996_version qcom_cpufreq_kryo_get_msm_id(void) + return version; + } + +-static int qcom_cpufreq_kryo_probe(struct platform_device *pdev) ++static int qcom_cpufreq_kryo_name_version(struct device *cpu_dev, ++ struct nvmem_cell *speedbin_nvmem, ++ u32 *versions) + { +- struct opp_table **opp_tables; ++ size_t len; ++ u8 *speedbin; + enum _msm8996_version msm8996_version; ++ ++ msm8996_version = qcom_cpufreq_get_msm_id(); ++ if (NUM_OF_MSM8996_VERSIONS == msm8996_version) { ++ dev_err(cpu_dev, "Not Snapdragon 820/821!"); ++ return -ENODEV; ++ } ++ ++ speedbin = nvmem_cell_read(speedbin_nvmem, &len); ++ if (IS_ERR(speedbin)) ++ return PTR_ERR(speedbin); ++ ++ switch (msm8996_version) { ++ case MSM8996_V3: ++ *versions = 1 << (unsigned int)(*speedbin); ++ break; ++ case MSM8996_SG: ++ *versions = 1 << ((unsigned int)(*speedbin) + 4); ++ break; ++ default: ++ BUG(); ++ break; ++ } ++ ++ kfree(speedbin); ++ return 0; ++} ++ ++static int qcom_cpufreq_probe(struct platform_device *pdev) ++{ ++ struct opp_table **opp_tables; ++ int (*get_version)(struct device *cpu_dev, ++ struct nvmem_cell *speedbin_nvmem, ++ u32 *versions); + struct nvmem_cell *speedbin_nvmem; + struct device_node *np; + struct device *cpu_dev; + unsigned cpu; +- u8 *speedbin; + u32 versions; +- size_t len; ++ const struct of_device_id *match; + int ret; + + cpu_dev = get_cpu_device(0); + if (!cpu_dev) + return -ENODEV; + +- msm8996_version = qcom_cpufreq_kryo_get_msm_id(); +- if (NUM_OF_MSM8996_VERSIONS == msm8996_version) { +- dev_err(cpu_dev, "Not Snapdragon 820/821!"); ++ match = pdev->dev.platform_data; ++ get_version = match->data; ++ if (!get_version) + return -ENODEV; +- } + + np = dev_pm_opp_of_get_opp_desc_node(cpu_dev); + if (!np) +@@ -115,23 +150,10 @@ static int qcom_cpufreq_kryo_probe(struct platform_device *pdev) + return PTR_ERR(speedbin_nvmem); + } + +- speedbin = nvmem_cell_read(speedbin_nvmem, &len); ++ ret = get_version(cpu_dev, speedbin_nvmem, &versions); + nvmem_cell_put(speedbin_nvmem); +- if (IS_ERR(speedbin)) +- return PTR_ERR(speedbin); +- +- switch (msm8996_version) { +- case MSM8996_V3: +- versions = 1 << (unsigned int)(*speedbin); +- break; +- case MSM8996_SG: +- versions = 1 << ((unsigned int)(*speedbin) + 4); +- break; +- default: +- BUG(); +- break; +- } +- kfree(speedbin); ++ if (ret) ++ return ret; + + opp_tables = kcalloc(num_possible_cpus(), sizeof(*opp_tables), GFP_KERNEL); + if (!opp_tables) +@@ -174,7 +196,7 @@ static int qcom_cpufreq_kryo_probe(struct platform_device *pdev) + return ret; + } + +-static int qcom_cpufreq_kryo_remove(struct platform_device *pdev) ++static int qcom_cpufreq_remove(struct platform_device *pdev) + { + struct opp_table **opp_tables = platform_get_drvdata(pdev); + unsigned int cpu; +@@ -189,18 +211,20 @@ static int qcom_cpufreq_kryo_remove(struct platform_device *pdev) + return 0; + } + +-static struct platform_driver qcom_cpufreq_kryo_driver = { +- .probe = qcom_cpufreq_kryo_probe, +- .remove = qcom_cpufreq_kryo_remove, ++static struct platform_driver qcom_cpufreq_driver = { ++ .probe = qcom_cpufreq_probe, ++ .remove = qcom_cpufreq_remove, + .driver = { +- .name = "qcom-cpufreq-kryo", ++ .name = "qcom-cpufreq-nvmem", + }, + }; + +-static const struct of_device_id qcom_cpufreq_kryo_match_list[] __initconst = { +- { .compatible = "qcom,apq8096", }, +- { .compatible = "qcom,msm8996", }, +- {} ++static const struct of_device_id qcom_cpufreq_match_list[] __initconst = { ++ { .compatible = "qcom,apq8096", ++ .data = qcom_cpufreq_kryo_name_version }, ++ { .compatible = "qcom,msm8996", ++ .data = qcom_cpufreq_kryo_name_version }, ++ {}, + }; + + /* +@@ -209,7 +233,7 @@ static const struct of_device_id qcom_cpufreq_kryo_match_list[] __initconst = { + * which may be defered as well. The init here is only registering + * the driver and the platform device. + */ +-static int __init qcom_cpufreq_kryo_init(void) ++static int __init qcom_cpufreq_init(void) + { + struct device_node *np = of_find_node_by_path("/"); + const struct of_device_id *match; +@@ -218,32 +242,32 @@ static int __init qcom_cpufreq_kryo_init(void) + if (!np) + return -ENODEV; + +- match = of_match_node(qcom_cpufreq_kryo_match_list, np); ++ match = of_match_node(qcom_cpufreq_match_list, np); + of_node_put(np); + if (!match) + return -ENODEV; + +- ret = platform_driver_register(&qcom_cpufreq_kryo_driver); ++ ret = platform_driver_register(&qcom_cpufreq_driver); + if (unlikely(ret < 0)) + return ret; + +- kryo_cpufreq_pdev = platform_device_register_simple( +- "qcom-cpufreq-kryo", -1, NULL, 0); +- ret = PTR_ERR_OR_ZERO(kryo_cpufreq_pdev); ++ cpufreq_pdev = platform_device_register_data(NULL, "qcom-cpufreq-nvmem", ++ -1, match, sizeof(*match)); ++ ret = PTR_ERR_OR_ZERO(cpufreq_pdev); + if (0 == ret) + return 0; + +- platform_driver_unregister(&qcom_cpufreq_kryo_driver); ++ platform_driver_unregister(&qcom_cpufreq_driver); + return ret; + } +-module_init(qcom_cpufreq_kryo_init); ++module_init(qcom_cpufreq_init); + +-static void __exit qcom_cpufreq_kryo_exit(void) ++static void __exit qcom_cpufreq_exit(void) + { +- platform_device_unregister(kryo_cpufreq_pdev); +- platform_driver_unregister(&qcom_cpufreq_kryo_driver); ++ platform_device_unregister(cpufreq_pdev); ++ platform_driver_unregister(&qcom_cpufreq_driver); + } +-module_exit(qcom_cpufreq_kryo_exit); ++module_exit(qcom_cpufreq_exit); + +-MODULE_DESCRIPTION("Qualcomm Technologies, Inc. Kryo CPUfreq driver"); ++MODULE_DESCRIPTION("Qualcomm Technologies, Inc. CPUfreq driver"); + MODULE_LICENSE("GPL v2"); diff --git a/target/linux/ipq806x/patches-4.19/0037-qcom-cpufreq-nvmem-Refactor-the-driver.patch b/target/linux/ipq806x/patches-4.19/0037-qcom-cpufreq-nvmem-Refactor-the-driver.patch new file mode 100644 index 0000000000..6c519c2c27 --- /dev/null +++ b/target/linux/ipq806x/patches-4.19/0037-qcom-cpufreq-nvmem-Refactor-the-driver.patch @@ -0,0 +1,243 @@ +From 57f2f8b4aa0c6b41a284da82bfa40dc3b2abe9a5 Mon Sep 17 00:00:00 2001 +From: Niklas Cassel +Date: Thu, 25 Jul 2019 12:41:33 +0200 +Subject: [PATCH] cpufreq: qcom: Refactor the driver to make it easier to + extend + +Refactor the driver to make it easier to extend in a later commit. + +Create a driver struct to collect all common resources, in order to make +it easier to free up all common resources. +Create a driver match_data struct to make it easier to extend the driver +with support for new features that might only be supported on certain SoCs. + +Co-developed-by: Jorge Ramirez-Ortiz +Signed-off-by: Jorge Ramirez-Ortiz +Signed-off-by: Niklas Cassel +Reviewed-by: Ilia Lin +Signed-off-by: Viresh Kumar +--- + drivers/cpufreq/qcom-cpufreq-nvmem.c | 123 +++++++++++++++++---------- + 1 file changed, 79 insertions(+), 44 deletions(-) + +diff --git a/drivers/cpufreq/qcom-cpufreq-nvmem.c b/drivers/cpufreq/qcom-cpufreq-nvmem.c +index fd08120768af2..2d798a1685c5d 100644 +--- a/drivers/cpufreq/qcom-cpufreq-nvmem.c ++++ b/drivers/cpufreq/qcom-cpufreq-nvmem.c +@@ -43,6 +43,20 @@ enum _msm8996_version { + NUM_OF_MSM8996_VERSIONS, + }; + ++struct qcom_cpufreq_drv; ++ ++struct qcom_cpufreq_match_data { ++ int (*get_version)(struct device *cpu_dev, ++ struct nvmem_cell *speedbin_nvmem, ++ struct qcom_cpufreq_drv *drv); ++}; ++ ++struct qcom_cpufreq_drv { ++ struct opp_table **opp_tables; ++ u32 versions; ++ const struct qcom_cpufreq_match_data *data; ++}; ++ + static struct platform_device *cpufreq_dt_pdev, *cpufreq_pdev; + + static enum _msm8996_version qcom_cpufreq_get_msm_id(void) +@@ -76,7 +90,7 @@ static enum _msm8996_version qcom_cpufreq_get_msm_id(void) + + static int qcom_cpufreq_kryo_name_version(struct device *cpu_dev, + struct nvmem_cell *speedbin_nvmem, +- u32 *versions) ++ struct qcom_cpufreq_drv *drv) + { + size_t len; + u8 *speedbin; +@@ -94,10 +108,10 @@ static int qcom_cpufreq_kryo_name_version(struct device *cpu_dev, + + switch (msm8996_version) { + case MSM8996_V3: +- *versions = 1 << (unsigned int)(*speedbin); ++ drv->versions = 1 << (unsigned int)(*speedbin); + break; + case MSM8996_SG: +- *versions = 1 << ((unsigned int)(*speedbin) + 4); ++ drv->versions = 1 << ((unsigned int)(*speedbin) + 4); + break; + default: + BUG(); +@@ -108,17 +122,17 @@ static int qcom_cpufreq_kryo_name_version(struct device *cpu_dev, + return 0; + } + ++static const struct qcom_cpufreq_match_data match_data_kryo = { ++ .get_version = qcom_cpufreq_kryo_name_version, ++}; ++ + static int qcom_cpufreq_probe(struct platform_device *pdev) + { +- struct opp_table **opp_tables; +- int (*get_version)(struct device *cpu_dev, +- struct nvmem_cell *speedbin_nvmem, +- u32 *versions); ++ struct qcom_cpufreq_drv *drv; + struct nvmem_cell *speedbin_nvmem; + struct device_node *np; + struct device *cpu_dev; + unsigned cpu; +- u32 versions; + const struct of_device_id *match; + int ret; + +@@ -126,11 +140,6 @@ static int qcom_cpufreq_probe(struct platform_device *pdev) + if (!cpu_dev) + return -ENODEV; + +- match = pdev->dev.platform_data; +- get_version = match->data; +- if (!get_version) +- return -ENODEV; +- + np = dev_pm_opp_of_get_opp_desc_node(cpu_dev); + if (!np) + return -ENOENT; +@@ -141,23 +150,43 @@ static int qcom_cpufreq_probe(struct platform_device *pdev) + return -ENOENT; + } + +- speedbin_nvmem = of_nvmem_cell_get(np, NULL); +- of_node_put(np); +- if (IS_ERR(speedbin_nvmem)) { +- if (PTR_ERR(speedbin_nvmem) != -EPROBE_DEFER) +- dev_err(cpu_dev, "Could not get nvmem cell: %ld\n", +- PTR_ERR(speedbin_nvmem)); +- return PTR_ERR(speedbin_nvmem); ++ drv = kzalloc(sizeof(*drv), GFP_KERNEL); ++ if (!drv) ++ return -ENOMEM; ++ ++ match = pdev->dev.platform_data; ++ drv->data = match->data; ++ if (!drv->data) { ++ ret = -ENODEV; ++ goto free_drv; + } + +- ret = get_version(cpu_dev, speedbin_nvmem, &versions); +- nvmem_cell_put(speedbin_nvmem); +- if (ret) +- return ret; ++ if (drv->data->get_version) { ++ speedbin_nvmem = of_nvmem_cell_get(np, NULL); ++ if (IS_ERR(speedbin_nvmem)) { ++ if (PTR_ERR(speedbin_nvmem) != -EPROBE_DEFER) ++ dev_err(cpu_dev, ++ "Could not get nvmem cell: %ld\n", ++ PTR_ERR(speedbin_nvmem)); ++ ret = PTR_ERR(speedbin_nvmem); ++ goto free_drv; ++ } + +- opp_tables = kcalloc(num_possible_cpus(), sizeof(*opp_tables), GFP_KERNEL); +- if (!opp_tables) +- return -ENOMEM; ++ ret = drv->data->get_version(cpu_dev, speedbin_nvmem, drv); ++ if (ret) { ++ nvmem_cell_put(speedbin_nvmem); ++ goto free_drv; ++ } ++ nvmem_cell_put(speedbin_nvmem); ++ } ++ of_node_put(np); ++ ++ drv->opp_tables = kcalloc(num_possible_cpus(), sizeof(*drv->opp_tables), ++ GFP_KERNEL); ++ if (!drv->opp_tables) { ++ ret = -ENOMEM; ++ goto free_drv; ++ } + + for_each_possible_cpu(cpu) { + cpu_dev = get_cpu_device(cpu); +@@ -166,19 +195,23 @@ static int qcom_cpufreq_probe(struct platform_device *pdev) + goto free_opp; + } + +- opp_tables[cpu] = dev_pm_opp_set_supported_hw(cpu_dev, +- &versions, 1); +- if (IS_ERR(opp_tables[cpu])) { +- ret = PTR_ERR(opp_tables[cpu]); +- dev_err(cpu_dev, "Failed to set supported hardware\n"); +- goto free_opp; ++ if (drv->data->get_version) { ++ drv->opp_tables[cpu] = ++ dev_pm_opp_set_supported_hw(cpu_dev, ++ &drv->versions, 1); ++ if (IS_ERR(drv->opp_tables[cpu])) { ++ ret = PTR_ERR(drv->opp_tables[cpu]); ++ dev_err(cpu_dev, ++ "Failed to set supported hardware\n"); ++ goto free_opp; ++ } + } + } + + cpufreq_dt_pdev = platform_device_register_simple("cpufreq-dt", -1, + NULL, 0); + if (!IS_ERR(cpufreq_dt_pdev)) { +- platform_set_drvdata(pdev, opp_tables); ++ platform_set_drvdata(pdev, drv); + return 0; + } + +@@ -187,26 +220,30 @@ static int qcom_cpufreq_probe(struct platform_device *pdev) + + free_opp: + for_each_possible_cpu(cpu) { +- if (IS_ERR_OR_NULL(opp_tables[cpu])) ++ if (IS_ERR_OR_NULL(drv->opp_tables[cpu])) + break; +- dev_pm_opp_put_supported_hw(opp_tables[cpu]); ++ dev_pm_opp_put_supported_hw(drv->opp_tables[cpu]); + } +- kfree(opp_tables); ++ kfree(drv->opp_tables); ++free_drv: ++ kfree(drv); + + return ret; + } + + static int qcom_cpufreq_remove(struct platform_device *pdev) + { +- struct opp_table **opp_tables = platform_get_drvdata(pdev); ++ struct qcom_cpufreq_drv *drv = platform_get_drvdata(pdev); + unsigned int cpu; + + platform_device_unregister(cpufreq_dt_pdev); + + for_each_possible_cpu(cpu) +- dev_pm_opp_put_supported_hw(opp_tables[cpu]); ++ if (drv->opp_tables[cpu]) ++ dev_pm_opp_put_supported_hw(drv->opp_tables[cpu]); + +- kfree(opp_tables); ++ kfree(drv->opp_tables); ++ kfree(drv); + + return 0; + } +@@ -220,10 +257,8 @@ static struct platform_driver qcom_cpufreq_driver = { + }; + + static const struct of_device_id qcom_cpufreq_match_list[] __initconst = { +- { .compatible = "qcom,apq8096", +- .data = qcom_cpufreq_kryo_name_version }, +- { .compatible = "qcom,msm8996", +- .data = qcom_cpufreq_kryo_name_version }, ++ { .compatible = "qcom,apq8096", .data = &match_data_kryo }, ++ { .compatible = "qcom,msm8996", .data = &match_data_kryo }, + {}, + }; +