iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cpufreq: qcom: Refactor the driver to make it easier to extend

Browse Source 
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>
This commit is contained in:
Niklas Cassel 2019-07-25 12:41:33 +02:00 committed by Viresh Kumar
parent 7d12709544
commit 57f2f8b4aa
1 changed files with 79 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
drivers/cpufreq/qcom-cpufreq-nvmem.c
View File

@ -43,6 +43,20 @@ enum _msm8996_version {
NUM_OF_MSM8996_VERSIONS, 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 struct platform_device *cpufreq_dt_pdev, *cpufreq_pdev;
static enum _msm8996_version qcom_cpufreq_get_msm_id(void) 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, static int qcom_cpufreq_kryo_name_version(struct device *cpu_dev,
struct nvmem_cell *speedbin_nvmem, struct nvmem_cell *speedbin_nvmem,
u32 *versions) struct qcom_cpufreq_drv *drv)
{ {
size_t len; size_t len;
u8 *speedbin; u8 *speedbin;
@ -94,10 +108,10 @@ static int qcom_cpufreq_kryo_name_version(struct device *cpu_dev,
switch (msm8996_version) { switch (msm8996_version) {
case MSM8996_V3: case MSM8996_V3:
*versions = 1 << (unsigned int)(*speedbin); drv->versions = 1 << (unsigned int)(*speedbin);
break; break;
case MSM8996_SG: case MSM8996_SG:
*versions = 1 << ((unsigned int)(*speedbin) + 4); drv->versions = 1 << ((unsigned int)(*speedbin) + 4);
break; break;
default: default:
BUG(); BUG();
@ -108,17 +122,17 @@ static int qcom_cpufreq_kryo_name_version(struct device *cpu_dev,
return 0; 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) static int qcom_cpufreq_probe(struct platform_device *pdev)
{ {
struct opp_table **opp_tables; struct qcom_cpufreq_drv *drv;
int (*get_version)(struct device *cpu_dev,
struct nvmem_cell *speedbin_nvmem,
u32 *versions);
struct nvmem_cell *speedbin_nvmem; struct nvmem_cell *speedbin_nvmem;
struct device_node *np; struct device_node *np;
struct device *cpu_dev; struct device *cpu_dev;
unsigned cpu; unsigned cpu;
u32 versions;
const struct of_device_id *match; const struct of_device_id *match;
int ret; int ret;
@ -126,11 +140,6 @@ static int qcom_cpufreq_probe(struct platform_device *pdev)
if (!cpu_dev) if (!cpu_dev)
return -ENODEV; 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); np = dev_pm_opp_of_get_opp_desc_node(cpu_dev);
if (!np) if (!np)
return -ENOENT; return -ENOENT;
@ -141,23 +150,43 @@ static int qcom_cpufreq_probe(struct platform_device *pdev)
return -ENOENT; return -ENOENT;
} }
speedbin_nvmem = of_nvmem_cell_get(np, NULL); drv = kzalloc(sizeof(*drv), GFP_KERNEL);
of_node_put(np); if (!drv)
if (IS_ERR(speedbin_nvmem)) { return -ENOMEM;
if (PTR_ERR(speedbin_nvmem) != -EPROBE_DEFER)
dev_err(cpu_dev, "Could not get nvmem cell: %ld\n", match = pdev->dev.platform_data;
PTR_ERR(speedbin_nvmem)); drv->data = match->data;
return PTR_ERR(speedbin_nvmem); if (!drv->data) {
ret = -ENODEV;
goto free_drv;
} }
ret = get_version(cpu_dev, speedbin_nvmem, &versions); if (drv->data->get_version) {
nvmem_cell_put(speedbin_nvmem); speedbin_nvmem = of_nvmem_cell_get(np, NULL);
if (ret) if (IS_ERR(speedbin_nvmem)) {
return ret; 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); ret = drv->data->get_version(cpu_dev, speedbin_nvmem, drv);
if (!opp_tables) if (ret) {
return -ENOMEM; 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) { for_each_possible_cpu(cpu) {
cpu_dev = get_cpu_device(cpu); cpu_dev = get_cpu_device(cpu);
@ -166,19 +195,23 @@ static int qcom_cpufreq_probe(struct platform_device *pdev)
goto free_opp; goto free_opp;
} }
opp_tables[cpu] = dev_pm_opp_set_supported_hw(cpu_dev, if (drv->data->get_version) {
&versions, 1); drv->opp_tables[cpu] =
if (IS_ERR(opp_tables[cpu])) { dev_pm_opp_set_supported_hw(cpu_dev,
ret = PTR_ERR(opp_tables[cpu]); &drv->versions, 1);
dev_err(cpu_dev, "Failed to set supported hardware\n"); if (IS_ERR(drv->opp_tables[cpu])) {
goto free_opp; 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, cpufreq_dt_pdev = platform_device_register_simple("cpufreq-dt", -1,
NULL, 0); NULL, 0);
if (!IS_ERR(cpufreq_dt_pdev)) { if (!IS_ERR(cpufreq_dt_pdev)) {
platform_set_drvdata(pdev, opp_tables); platform_set_drvdata(pdev, drv);
return 0; return 0;
} }
@ -187,26 +220,30 @@ static int qcom_cpufreq_probe(struct platform_device *pdev)
free_opp: free_opp:
for_each_possible_cpu(cpu) { for_each_possible_cpu(cpu) {
if (IS_ERR_OR_NULL(opp_tables[cpu])) if (IS_ERR_OR_NULL(drv->opp_tables[cpu]))
break; 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; return ret;
} }
static int qcom_cpufreq_remove(struct platform_device *pdev) 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; unsigned int cpu;
platform_device_unregister(cpufreq_dt_pdev); platform_device_unregister(cpufreq_dt_pdev);
for_each_possible_cpu(cpu) 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; return 0;
} }
@ -220,10 +257,8 @@ static struct platform_driver qcom_cpufreq_driver = {
}; };
static const struct of_device_id qcom_cpufreq_match_list[] __initconst = { static const struct of_device_id qcom_cpufreq_match_list[] __initconst = {
{ .compatible = "qcom,apq8096", { .compatible = "qcom,apq8096", .data = &match_data_kryo },
.data = qcom_cpufreq_kryo_name_version }, { .compatible = "qcom,msm8996", .data = &match_data_kryo },
{ .compatible = "qcom,msm8996",
.data = qcom_cpufreq_kryo_name_version },
{}, {},
}; };