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 <s.l-h@gmx.de> [nbg6817/ipq8065]
Signed-off-by: Ansuel Smith <ansuelsmth@gmail.com>

target/linux/ipq806x/patches-4.19/0035-qcom-cpufreq-nvmem-qcm-kyrp_make_Some_variables_static.patch

+From 50c0b12f098fb3cfac7abcc0f2b5409f6bac5fa2 Mon Sep 17 00:00:00 2001
+From: Yangtao Li <tiny.windzz@gmail.com>
+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 <tiny.windzz@gmail.com>
+Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
+---
+ 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)
+ {

target/linux/ipq806x/patches-4.19/0036-qcom-cpufreq-nvmem-Re-organise-kryo-cpufreq-driver.patch

+From 7d12709544b8b3fb9727a34a664b8380e1e3493a Mon Sep 17 00:00:00 2001
+From: Sricharan R <sricharan@codeaurora.org>
+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 <sricharan@codeaurora.org>
+[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 <niklas.cassel@linaro.org>
+Reviewed-by: Ilia Lin <ilia.lin@kernel.org>
+Reviewed-by: Stephen Boyd <sboyd@kernel.org>
+Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
+---
+ 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 <linux/module.h>
+ #include <linux/nvmem-consumer.h>
+ #include <linux/of.h>
++#include <linux/of_device.h>
+ #include <linux/platform_device.h>
+ #include <linux/pm_opp.h>
+ #include <linux/slab.h>
+@@ -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");

target/linux/ipq806x/patches-4.19/0037-qcom-cpufreq-nvmem-Refactor-the-driver.patch

+From 57f2f8b4aa0c6b41a284da82bfa40dc3b2abe9a5 Mon Sep 17 00:00:00 2001
+From: Niklas Cassel <niklas.cassel@linaro.org>
+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 <jorge.ramirez-ortiz@linaro.org>
+Signed-off-by: Jorge Ramirez-Ortiz <jorge.ramirez-ortiz@linaro.org>
+Signed-off-by: Niklas Cassel <niklas.cassel@linaro.org>
+Reviewed-by: Ilia Lin <ilia.lin@kernel.org>
+Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
+---
+ 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 },
+ 	{},
+ };
+