Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-27 22:51:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

clk: mediatek: Migrate to mtk_clk_pdev_probe() for multimedia clocks

Browse Source 
Reduce duplication and simplify all MediaTek multimedia clock drivers
by migrating away from defining custom probe functions for each driver
and instead use mtk_clk_pdev_probe().

While at it, also add a .remove() callback to all of the multimedia
clock drivers where missing.

Signed-off-by: AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>
Reviewed-by: Chen-Yu Tsai <wenst@chromium.org>
Tested-by: Miles Chen <miles.chen@mediatek.com>
Tested-by: Chen-Yu Tsai <wenst@chromium.org>
Link: https://lore.kernel.org/r/20230306140543.1813621-4-angelogioacchino.delregno@collabora.com
Signed-off-by: Stephen Boyd <sboyd@kernel.org>
This commit is contained in:
AngeloGioacchino Del Regno 2023-03-06 15:04:52 +01:00 committed by Stephen Boyd
parent 2520912424
commit 65c10c50c9
15 changed files with 164 additions and 479 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
drivers/clk/mediatek/clk-mt2701-mm.c
View File

@ -79,32 +79,23 @@ static const struct mtk_gate mm_clks[] = {
GATE_DISP1(CLK_MM_TVE_FMM, "mm_tve_fmm", "mm_sel", 14),
};
static int clk_mt2701_mm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data;
int r;
static const struct mtk_clk_desc mm_desc = {
.clks = mm_clks,
.num_clks = ARRAY_SIZE(mm_clks),
};
clk_data = mtk_alloc_clk_data(CLK_MM_NR);
mtk_clk_register_gates(&pdev->dev, node, mm_clks,
ARRAY_SIZE(mm_clks), clk_data);
r = of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
if (r)
dev_err(&pdev->dev,
"could not register clock provider: %s: %d\n",
pdev->name, r);
return r;
}
static const struct platform_device_id clk_mt2701_mm_id_table[] = {
{ .name = "clk-mt2701-mm", .driver_data = (kernel_ulong_t)&mm_desc },
{ /* sentinel */ }
};
static struct platform_driver clk_mt2701_mm_drv = {
.probe = clk_mt2701_mm_probe,
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
.driver = {
.name = "clk-mt2701-mm",
},
.id_table = clk_mt2701_mm_id_table,
};
builtin_platform_driver(clk_mt2701_mm_drv);

31
drivers/clk/mediatek/clk-mt2712-mm.c
View File

@ -126,32 +126,23 @@ static const struct mtk_gate mm_clks[] = {
GATE_MM2(CLK_MM_DSI3_DIGITAL, "mm_dsi3_digital", "dsi1_lntc", 6),
};
static int clk_mt2712_mm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data;
int r;
static const struct mtk_clk_desc mm_desc = {
.clks = mm_clks,
.num_clks = ARRAY_SIZE(mm_clks),
};
clk_data = mtk_alloc_clk_data(CLK_MM_NR_CLK);
mtk_clk_register_gates(&pdev->dev, node, mm_clks,
ARRAY_SIZE(mm_clks), clk_data);
r = of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
if (r != 0)
pr_err("%s(): could not register clock provider: %d\n",
__func__, r);
return r;
}
static const struct platform_device_id clk_mt2712_mm_id_table[] = {
{ .name = "clk-mt2712-mm", .driver_data = (kernel_ulong_t)&mm_desc },
{ /* sentinel */ }
};
static struct platform_driver clk_mt2712_mm_drv = {
.probe = clk_mt2712_mm_probe,
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
.driver = {
.name = "clk-mt2712-mm",
},
.id_table = clk_mt2712_mm_id_table,
};
builtin_platform_driver(clk_mt2712_mm_drv);

24
drivers/clk/mediatek/clk-mt6779-mm.c
View File

@ -85,25 +85,23 @@ static const struct mtk_gate mm_clks[] = {
GATE_MM1(CLK_MM_DISP_OVL_FBDC, "mm_disp_ovl_fbdc", "mm_sel", 16),
};
static int clk_mt6779_mm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data;
static const struct mtk_clk_desc mm_desc = {
.clks = mm_clks,
.num_clks = ARRAY_SIZE(mm_clks),
};
clk_data = mtk_alloc_clk_data(CLK_MM_NR_CLK);
mtk_clk_register_gates(&pdev->dev, node, mm_clks,
ARRAY_SIZE(mm_clks), clk_data);
return of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
}
static const struct platform_device_id clk_mt6779_mm_id_table[] = {
{ .name = "clk-mt6779-mm", .driver_data = (kernel_ulong_t)&mm_desc },
{ /* sentinel */ }
};
static struct platform_driver clk_mt6779_mm_drv = {
.probe = clk_mt6779_mm_probe,
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
.driver = {
.name = "clk-mt6779-mm",
},
.id_table = clk_mt6779_mm_id_table,
};
module_platform_driver(clk_mt6779_mm_drv);

55
drivers/clk/mediatek/clk-mt6795-mm.c
View File

@ -76,56 +76,23 @@ static const struct mtk_gate mm_gates[] = {
GATE_MM1(CLK_MM_DPI_ENGINE, "mm_dpi_engine", "mm_sel", 9),
};
static int clk_mt6795_mm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data;
int ret;
static const struct mtk_clk_desc mm_desc = {
.clks = mm_gates,
.num_clks = ARRAY_SIZE(mm_gates),
};
clk_data = mtk_alloc_clk_data(CLK_MM_NR_CLK);
if (!clk_data)
return -ENOMEM;
ret = mtk_clk_register_gates(&pdev->dev, node, mm_gates,
ARRAY_SIZE(mm_gates), clk_data);
if (ret)
goto free_clk_data;
ret = of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
if (ret)
goto unregister_gates;
platform_set_drvdata(pdev, clk_data);
return 0;
unregister_gates:
mtk_clk_unregister_gates(mm_gates, ARRAY_SIZE(mm_gates), clk_data);
free_clk_data:
mtk_free_clk_data(clk_data);
return ret;
}
static int clk_mt6795_mm_remove(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data = platform_get_drvdata(pdev);
of_clk_del_provider(node);
mtk_clk_unregister_gates(mm_gates, ARRAY_SIZE(mm_gates), clk_data);
mtk_free_clk_data(clk_data);
return 0;
}
static const struct platform_device_id clk_mt6795_mm_id_table[] = {
{ .name = "clk-mt6795-mm", .driver_data = (kernel_ulong_t)&mm_desc },
{ /* sentinel */ }
};
static struct platform_driver clk_mt6795_mm_drv = {
.driver = {
.name = "clk-mt6795-mm",
},
.probe = clk_mt6795_mm_probe,
.remove = clk_mt6795_mm_remove,
.id_table = clk_mt6795_mm_id_table,
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
};
module_platform_driver(clk_mt6795_mm_drv);

31
drivers/clk/mediatek/clk-mt6797-mm.c
View File

@ -92,32 +92,23 @@ static const struct mtk_gate mm_clks[] = {
"clk26m", 3),
};
static int clk_mt6797_mm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data;
int r;
static const struct mtk_clk_desc mm_desc = {
.clks = mm_clks,
.num_clks = ARRAY_SIZE(mm_clks),
};
clk_data = mtk_alloc_clk_data(CLK_MM_NR);
mtk_clk_register_gates(&pdev->dev, node, mm_clks,
ARRAY_SIZE(mm_clks), clk_data);
r = of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
if (r)
dev_err(&pdev->dev,
"could not register clock provider: %s: %d\n",
pdev->name, r);
return r;
}
static const struct platform_device_id clk_mt6797_mm_id_table[] = {
{ .name = "clk-mt6797-mm", .driver_data = (kernel_ulong_t)&mm_desc },
{ /* sentinel */ }
};
static struct platform_driver clk_mt6797_mm_drv = {
.probe = clk_mt6797_mm_probe,
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
.driver = {
.name = "clk-mt6797-mm",
},
.id_table = clk_mt6797_mm_id_table,
};
builtin_platform_driver(clk_mt6797_mm_drv);

47
drivers/clk/mediatek/clk-mt8167-mm.c
View File

@ -86,47 +86,22 @@ static const struct mtk_gate mm_clks[] = {
GATE_MM1(CLK_MM_HDMI_PLL, "mm_hdmi_pll", "hdmtx_dig_cts", 21),
};
struct clk_mt8167_mm_driver_data {
const struct mtk_gate *gates_clk;
int gates_num;
static const struct mtk_clk_desc mm_desc = {
.clks = mm_clks,
.num_clks = ARRAY_SIZE(mm_clks),
};
static const struct clk_mt8167_mm_driver_data mt8167_mmsys_driver_data = {
.gates_clk = mm_clks,
.gates_num = ARRAY_SIZE(mm_clks),
static const struct platform_device_id clk_mt8167_mm_id_table[] = {
{ .name = "clk-mt8167-mm", .driver_data = (kernel_ulong_t)&mm_desc },
{ /* sentinel */ }
};
static int clk_mt8167_mm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
const struct clk_mt8167_mm_driver_data *data;
struct clk_hw_onecell_data *clk_data;
int ret;
clk_data = mtk_alloc_clk_data(CLK_MM_NR_CLK);
if (!clk_data)
return -ENOMEM;
data = &mt8167_mmsys_driver_data;
ret = mtk_clk_register_gates(&pdev->dev, node, data->gates_clk,
data->gates_num, clk_data);
if (ret)
return ret;
ret = of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
if (ret)
return ret;
return 0;
}
static struct platform_driver clk_mt8173_mm_drv = {
static struct platform_driver clk_mt8167_mm_drv = {
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
.driver = {
.name = "clk-mt8167-mm",
},
.probe = clk_mt8167_mm_probe,
.id_table = clk_mt8167_mm_id_table,
};
builtin_platform_driver(clk_mt8173_mm_drv);
builtin_platform_driver(clk_mt8167_mm_drv);

58
drivers/clk/mediatek/clk-mt8173-mm.c
View File

@ -44,6 +44,7 @@ static const struct mtk_gate_regs mm1_cg_regs = {
}
static const struct mtk_gate mt8173_mm_clks[] = {
GATE_DUMMY(CLK_DUMMY, "mm_dummy"),
/* MM0 */
GATE_MM0(CLK_MM_SMI_COMMON, "mm_smi_common", "mm_sel", 0),
GATE_MM0(CLK_MM_SMI_LARB0, "mm_smi_larb0", "mm_sel", 1),
@ -100,62 +101,23 @@ static const struct mtk_gate mt8173_mm_clks[] = {
GATE_MM1(CLK_MM_HDMI_HDCP24M, "mm_hdmi_hdcp24m", "hdcp_24m_sel", 20),
};
struct clk_mt8173_mm_driver_data {
const struct mtk_gate *gates_clk;
int gates_num;
static const struct mtk_clk_desc mm_desc = {
.clks = mt8173_mm_clks,
.num_clks = ARRAY_SIZE(mt8173_mm_clks),
};
static const struct clk_mt8173_mm_driver_data mt8173_mmsys_driver_data = {
.gates_clk = mt8173_mm_clks,
.gates_num = ARRAY_SIZE(mt8173_mm_clks),
static const struct platform_device_id clk_mt8173_mm_id_table[] = {
{ .name = "clk-mt8173-mm", .driver_data = (kernel_ulong_t)&mm_desc },
{ /* sentinel */ }
};
static int clk_mt8173_mm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
const struct clk_mt8173_mm_driver_data *data;
struct clk_hw_onecell_data *clk_data;
int ret;
clk_data = mtk_alloc_clk_data(CLK_MM_NR_CLK);
if (!clk_data)
return -ENOMEM;
data = &mt8173_mmsys_driver_data;
ret = mtk_clk_register_gates(&pdev->dev, node, data->gates_clk,
data->gates_num, clk_data);
if (ret)
return ret;
ret = of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
if (ret)
return ret;
return 0;
}
static int clk_mt8173_mm_remove(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data = platform_get_drvdata(pdev);
const struct clk_mt8173_mm_driver_data *data = &mt8173_mmsys_driver_data;
of_clk_del_provider(node);
mtk_clk_unregister_gates(data->gates_clk, data->gates_num, clk_data);
mtk_free_clk_data(clk_data);
return 0;
}
static struct platform_driver clk_mt8173_mm_drv = {
.driver = {
.name = "clk-mt8173-mm",
},
.probe = clk_mt8173_mm_probe,
.remove = clk_mt8173_mm_remove,
.id_table = clk_mt8173_mm_id_table,
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
};
builtin_platform_driver(clk_mt8173_mm_drv);

24
drivers/clk/mediatek/clk-mt8183-mm.c
View File

@ -82,25 +82,23 @@ static const struct mtk_gate mm_clks[] = {
GATE_MM1(CLK_MM_DBI_IF, "mm_dbi_if", "dpi0_sel", 13),
};
static int clk_mt8183_mm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data;
static const struct mtk_clk_desc mm_desc = {
.clks = mm_clks,
.num_clks = ARRAY_SIZE(mm_clks),
};
clk_data = mtk_alloc_clk_data(CLK_MM_NR_CLK);
mtk_clk_register_gates(&pdev->dev, node, mm_clks,
ARRAY_SIZE(mm_clks), clk_data);
return of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
}
static const struct platform_device_id clk_mt8183_mm_id_table[] = {
{ .name = "clk-mt8183-mm", .driver_data = (kernel_ulong_t)&mm_desc },
{ /* sentinel */ }
};
static struct platform_driver clk_mt8183_mm_drv = {
.probe = clk_mt8183_mm_probe,
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
.driver = {
.name = "clk-mt8183-mm",
},
.id_table = clk_mt8183_mm_id_table,
};
builtin_platform_driver(clk_mt8183_mm_drv);

56
drivers/clk/mediatek/clk-mt8186-mm.c
View File

@ -58,55 +58,21 @@ static const struct mtk_gate mm_clks[] = {
GATE_MM1(CLK_MM_DISP_26M, "mm_disp_26m_ck", "top_disp", 10),
};
static int clk_mt8186_mm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data;
int r;
clk_data = mtk_alloc_clk_data(CLK_MM_NR_CLK);
if (!clk_data)
return -ENOMEM;
r = mtk_clk_register_gates(&pdev->dev, node, mm_clks,
ARRAY_SIZE(mm_clks), clk_data);
if (r)
goto free_mm_data;
r = of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
if (r)
goto unregister_gates;
platform_set_drvdata(pdev, clk_data);
return r;
unregister_gates:
mtk_clk_unregister_gates(mm_clks, ARRAY_SIZE(mm_clks), clk_data);
free_mm_data:
mtk_free_clk_data(clk_data);
return r;
}
static int clk_mt8186_mm_remove(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data = platform_get_drvdata(pdev);
of_clk_del_provider(node);
mtk_clk_unregister_gates(mm_clks, ARRAY_SIZE(mm_clks), clk_data);
mtk_free_clk_data(clk_data);
return 0;
}
static const struct mtk_clk_desc mm_desc = {
.clks = mm_clks,
.num_clks = ARRAY_SIZE(mm_clks),
};
static const struct platform_device_id clk_mt8186_mm_id_table[] = {
{ .name = "clk-mt8186-mm", .driver_data = (kernel_ulong_t)&mm_desc },
{ /* sentinel */ }
};
static struct platform_driver clk_mt8186_mm_drv = {
.probe = clk_mt8186_mm_probe,
.remove = clk_mt8186_mm_remove,
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
.driver = {
.name = "clk-mt8186-mm",
},
.id_table = clk_mt8186_mm_id_table,
};
builtin_platform_driver(clk_mt8186_mm_drv);

29
drivers/clk/mediatek/clk-mt8192-mm.c
View File

@ -80,30 +80,23 @@ static const struct mtk_gate mm_clks[] = {
GATE_MM2(CLK_MM_32KHZ, "mm_32khz", "clk32k", 25),
};
static int clk_mt8192_mm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data;
int r;
static const struct mtk_clk_desc mm_desc = {
.clks = mm_clks,
.num_clks = ARRAY_SIZE(mm_clks),
};
clk_data = mtk_alloc_clk_data(CLK_MM_NR_CLK);
if (!clk_data)
return -ENOMEM;
r = mtk_clk_register_gates(&pdev->dev, node, mm_clks,
ARRAY_SIZE(mm_clks), clk_data);
if (r)
return r;
return of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
}
static const struct platform_device_id clk_mt8192_mm_id_table[] = {
{ .name = "clk-mt8192-mm", .driver_data = (kernel_ulong_t)&mm_desc },
{ /* sentinel */ }
};
static struct platform_driver clk_mt8192_mm_drv = {
.probe = clk_mt8192_mm_probe,
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
.driver = {
.name = "clk-mt8192-mm",
},
.id_table = clk_mt8192_mm_id_table,
};
builtin_platform_driver(clk_mt8192_mm_drv);

55
drivers/clk/mediatek/clk-mt8195-vdo0.c
View File

@ -93,55 +93,22 @@ static const struct mtk_gate vdo0_clks[] = {
"top_edp", 16, CLK_SET_RATE_PARENT),
};
static int clk_mt8195_vdo0_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data;
int r;
static const struct mtk_clk_desc vdo0_desc = {
.clks = vdo0_clks,
.num_clks = ARRAY_SIZE(vdo0_clks),
};
clk_data = mtk_alloc_clk_data(CLK_VDO0_NR_CLK);
if (!clk_data)
return -ENOMEM;
r = mtk_clk_register_gates(&pdev->dev, node, vdo0_clks,
ARRAY_SIZE(vdo0_clks), clk_data);
if (r)
goto free_vdo0_data;
r = of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
if (r)
goto unregister_gates;
platform_set_drvdata(pdev, clk_data);
return r;
unregister_gates:
mtk_clk_unregister_gates(vdo0_clks, ARRAY_SIZE(vdo0_clks), clk_data);
free_vdo0_data:
mtk_free_clk_data(clk_data);
return r;
}
static int clk_mt8195_vdo0_remove(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data = platform_get_drvdata(pdev);
of_clk_del_provider(node);
mtk_clk_unregister_gates(vdo0_clks, ARRAY_SIZE(vdo0_clks), clk_data);
mtk_free_clk_data(clk_data);
return 0;
}
static const struct platform_device_id clk_mt8195_vdo0_id_table[] = {
{ .name = "clk-mt8195-vdo0", .driver_data = (kernel_ulong_t)&vdo0_desc },
{ /* sentinel */ }
};
static struct platform_driver clk_mt8195_vdo0_drv = {
.probe = clk_mt8195_vdo0_probe,
.remove = clk_mt8195_vdo0_remove,
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
.driver = {
.name = "clk-mt8195-vdo0",
},
.id_table = clk_mt8195_vdo0_id_table,
};
builtin_platform_driver(clk_mt8195_vdo0_drv);

55
drivers/clk/mediatek/clk-mt8195-vdo1.c
View File

@ -120,55 +120,22 @@ static const struct mtk_gate vdo1_clks[] = {
GATE_VDO1_4(CLK_VDO1_DPI1_HDMI, "vdo1_dpi1_hdmi", "hdmi_txpll", 0),
};
static int clk_mt8195_vdo1_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data;
int r;
static const struct mtk_clk_desc vdo1_desc = {
.clks = vdo1_clks,
.num_clks = ARRAY_SIZE(vdo1_clks),
};
clk_data = mtk_alloc_clk_data(CLK_VDO1_NR_CLK);
if (!clk_data)
return -ENOMEM;
r = mtk_clk_register_gates(&pdev->dev, node, vdo1_clks,
ARRAY_SIZE(vdo1_clks), clk_data);
if (r)
goto free_vdo1_data;
r = of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
if (r)
goto unregister_gates;
platform_set_drvdata(pdev, clk_data);
return r;
unregister_gates:
mtk_clk_unregister_gates(vdo1_clks, ARRAY_SIZE(vdo1_clks), clk_data);
free_vdo1_data:
mtk_free_clk_data(clk_data);
return r;
}
static int clk_mt8195_vdo1_remove(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data = platform_get_drvdata(pdev);
of_clk_del_provider(node);
mtk_clk_unregister_gates(vdo1_clks, ARRAY_SIZE(vdo1_clks), clk_data);
mtk_free_clk_data(clk_data);
return 0;
}
static const struct platform_device_id clk_mt8195_vdo1_id_table[] = {
{ .name = "clk-mt8195-vdo1", .driver_data = (kernel_ulong_t)&vdo1_desc },
{ /* sentinel */ }
};
static struct platform_driver clk_mt8195_vdo1_drv = {
.probe = clk_mt8195_vdo1_probe,
.remove = clk_mt8195_vdo1_remove,
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
.driver = {
.name = "clk-mt8195-vdo1",
},
.id_table = clk_mt8195_vdo1_id_table,
};
builtin_platform_driver(clk_mt8195_vdo1_drv);

54
drivers/clk/mediatek/clk-mt8195-vpp0.c
View File

@ -86,54 +86,22 @@ static const struct mtk_gate vpp0_clks[] = {
GATE_VPP0_2(CLK_VPP0_WARP1_MDP_DL_ASYNC, "vpp0_warp1_mdp_dl_async", "top_wpe_vpp", 3),
};
static int clk_mt8195_vpp0_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data;
int r;
static const struct mtk_clk_desc vpp0_desc = {
.clks = vpp0_clks,
.num_clks = ARRAY_SIZE(vpp0_clks),
};
clk_data = mtk_alloc_clk_data(CLK_VPP0_NR_CLK);
if (!clk_data)
return -ENOMEM;
r = mtk_clk_register_gates(dev, node, vpp0_clks, ARRAY_SIZE(vpp0_clks), clk_data);
if (r)
goto free_vpp0_data;
r = of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
if (r)
goto unregister_gates;
platform_set_drvdata(pdev, clk_data);
return r;
unregister_gates:
mtk_clk_unregister_gates(vpp0_clks, ARRAY_SIZE(vpp0_clks), clk_data);
free_vpp0_data:
mtk_free_clk_data(clk_data);
return r;
}
static int clk_mt8195_vpp0_remove(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data = platform_get_drvdata(pdev);
of_clk_del_provider(node);
mtk_clk_unregister_gates(vpp0_clks, ARRAY_SIZE(vpp0_clks), clk_data);
mtk_free_clk_data(clk_data);
return 0;
}
static const struct platform_device_id clk_mt8195_vpp0_id_table[] = {
{ .name = "clk-mt8195-vpp0", .driver_data = (kernel_ulong_t)&vpp0_desc },
{ /* sentinel */ }
};
static struct platform_driver clk_mt8195_vpp0_drv = {
.probe = clk_mt8195_vpp0_probe,
.remove = clk_mt8195_vpp0_remove,
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
.driver = {
.name = "clk-mt8195-vpp0",
},
.id_table = clk_mt8195_vpp0_id_table,
};
builtin_platform_driver(clk_mt8195_vpp0_drv);

54
drivers/clk/mediatek/clk-mt8195-vpp1.c
View File

@ -84,54 +84,22 @@ static const struct mtk_gate vpp1_clks[] = {
GATE_VPP1_1(CLK_VPP1_VPP_SPLIT_26M, "vpp1_vpp_split_26m", "clk26m", 26),
};
static int clk_mt8195_vpp1_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data;
int r;
static const struct mtk_clk_desc vpp1_desc = {
.clks = vpp1_clks,
.num_clks = ARRAY_SIZE(vpp1_clks),
};
clk_data = mtk_alloc_clk_data(CLK_VPP1_NR_CLK);
if (!clk_data)
return -ENOMEM;
r = mtk_clk_register_gates(dev, node, vpp1_clks, ARRAY_SIZE(vpp1_clks), clk_data);
if (r)
goto free_vpp1_data;
r = of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
if (r)
goto unregister_gates;
platform_set_drvdata(pdev, clk_data);
return r;
unregister_gates:
mtk_clk_unregister_gates(vpp1_clks, ARRAY_SIZE(vpp1_clks), clk_data);
free_vpp1_data:
mtk_free_clk_data(clk_data);
return r;
}
static int clk_mt8195_vpp1_remove(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data = platform_get_drvdata(pdev);
of_clk_del_provider(node);
mtk_clk_unregister_gates(vpp1_clks, ARRAY_SIZE(vpp1_clks), clk_data);
mtk_free_clk_data(clk_data);
return 0;
}
static const struct platform_device_id clk_mt8195_vpp1_id_table[] = {
{ .name = "clk-mt8195-vpp1", .driver_data = (kernel_ulong_t)&vpp1_desc },
{ /* sentinel */ }
};
static struct platform_driver clk_mt8195_vpp1_drv = {
.probe = clk_mt8195_vpp1_probe,
.remove = clk_mt8195_vpp1_remove,
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
.driver = {
.name = "clk-mt8195-vpp1",
},
.id_table = clk_mt8195_vpp1_id_table,
};
builtin_platform_driver(clk_mt8195_vpp1_drv);

39
drivers/clk/mediatek/clk-mt8365-mm.c
View File

@ -72,40 +72,23 @@ static const struct mtk_gate mm_clks[] = {
GATE_MM1(CLK_MM_LVDSTX_CTS, "mm_flvdstx_cts", "lvdstx_dig_cts", 3),
};
static int clk_mt8365_mm_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->parent->of_node;
struct clk_hw_onecell_data *clk_data;
int ret;
static const struct mtk_clk_desc mm_desc = {
.clks = mm_clks,
.num_clks = ARRAY_SIZE(mm_clks),
};
clk_data = mtk_alloc_clk_data(CLK_MM_NR_CLK);
ret = mtk_clk_register_gates(dev, node, mm_clks,
ARRAY_SIZE(mm_clks), clk_data);
if (ret)
goto err_free_clk_data;
ret = of_clk_add_hw_provider(node, of_clk_hw_onecell_get, clk_data);
if (ret)
goto err_unregister_gates;
return 0;
err_unregister_gates:
mtk_clk_unregister_gates(mm_clks, ARRAY_SIZE(mm_clks), clk_data);
err_free_clk_data:
mtk_free_clk_data(clk_data);
return ret;
}
static const struct platform_device_id clk_mt8365_mm_id_table[] = {
{ .name = "clk-mt8365-mm", .driver_data = (kernel_ulong_t)&mm_desc },
{ /* sentinel */ }
};
static struct platform_driver clk_mt8365_mm_drv = {
.probe = clk_mt8365_mm_probe,
.probe = mtk_clk_pdev_probe,
.remove = mtk_clk_pdev_remove,
.driver = {
.name = "clk-mt8365-mm",
},
.id_table = clk_mt8365_mm_id_table,
};
builtin_platform_driver(clk_mt8365_mm_drv);
MODULE_LICENSE("GPL");