1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * PRCC clock implementation for ux500 platform.
4  *
5  * Copyright (C) 2012 ST-Ericsson SA
6  * Author: Ulf Hansson <ulf.hansson@linaro.org>
7  */
8 
9 #include <linux/clk-provider.h>
10 #include <linux/slab.h>
11 #include <linux/io.h>
12 #include <linux/err.h>
13 #include <linux/types.h>
14 
15 #include "clk.h"
16 
17 #define PRCC_PCKEN			0x000
18 #define PRCC_PCKDIS			0x004
19 #define PRCC_KCKEN			0x008
20 #define PRCC_KCKDIS			0x00C
21 #define PRCC_PCKSR			0x010
22 #define PRCC_KCKSR			0x014
23 
24 #define to_clk_prcc(_hw) container_of(_hw, struct clk_prcc, hw)
25 
26 struct clk_prcc {
27 	struct clk_hw hw;
28 	void __iomem *base;
29 	u32 cg_sel;
30 	int is_enabled;
31 };
32 
33 /* PRCC clock operations. */
34 
clk_prcc_pclk_enable(struct clk_hw * hw)35 static int clk_prcc_pclk_enable(struct clk_hw *hw)
36 {
37 	struct clk_prcc *clk = to_clk_prcc(hw);
38 
39 	writel(clk->cg_sel, (clk->base + PRCC_PCKEN));
40 	while (!(readl(clk->base + PRCC_PCKSR) & clk->cg_sel))
41 		cpu_relax();
42 
43 	clk->is_enabled = 1;
44 	return 0;
45 }
46 
clk_prcc_pclk_disable(struct clk_hw * hw)47 static void clk_prcc_pclk_disable(struct clk_hw *hw)
48 {
49 	struct clk_prcc *clk = to_clk_prcc(hw);
50 
51 	writel(clk->cg_sel, (clk->base + PRCC_PCKDIS));
52 	clk->is_enabled = 0;
53 }
54 
clk_prcc_kclk_enable(struct clk_hw * hw)55 static int clk_prcc_kclk_enable(struct clk_hw *hw)
56 {
57 	struct clk_prcc *clk = to_clk_prcc(hw);
58 
59 	writel(clk->cg_sel, (clk->base + PRCC_KCKEN));
60 	while (!(readl(clk->base + PRCC_KCKSR) & clk->cg_sel))
61 		cpu_relax();
62 
63 	clk->is_enabled = 1;
64 	return 0;
65 }
66 
clk_prcc_kclk_disable(struct clk_hw * hw)67 static void clk_prcc_kclk_disable(struct clk_hw *hw)
68 {
69 	struct clk_prcc *clk = to_clk_prcc(hw);
70 
71 	writel(clk->cg_sel, (clk->base + PRCC_KCKDIS));
72 	clk->is_enabled = 0;
73 }
74 
clk_prcc_is_enabled(struct clk_hw * hw)75 static int clk_prcc_is_enabled(struct clk_hw *hw)
76 {
77 	struct clk_prcc *clk = to_clk_prcc(hw);
78 	return clk->is_enabled;
79 }
80 
81 static const struct clk_ops clk_prcc_pclk_ops = {
82 	.enable = clk_prcc_pclk_enable,
83 	.disable = clk_prcc_pclk_disable,
84 	.is_enabled = clk_prcc_is_enabled,
85 };
86 
87 static const struct clk_ops clk_prcc_kclk_ops = {
88 	.enable = clk_prcc_kclk_enable,
89 	.disable = clk_prcc_kclk_disable,
90 	.is_enabled = clk_prcc_is_enabled,
91 };
92 
clk_reg_prcc(const char * name,const char * parent_name,resource_size_t phy_base,u32 cg_sel,unsigned long flags,const struct clk_ops * clk_prcc_ops)93 static struct clk *clk_reg_prcc(const char *name,
94 				const char *parent_name,
95 				resource_size_t phy_base,
96 				u32 cg_sel,
97 				unsigned long flags,
98 				const struct clk_ops *clk_prcc_ops)
99 {
100 	struct clk_prcc *clk;
101 	struct clk_init_data clk_prcc_init;
102 	struct clk *clk_reg;
103 
104 	if (!name) {
105 		pr_err("clk_prcc: %s invalid arguments passed\n", __func__);
106 		return ERR_PTR(-EINVAL);
107 	}
108 
109 	clk = kzalloc(sizeof(*clk), GFP_KERNEL);
110 	if (!clk)
111 		return ERR_PTR(-ENOMEM);
112 
113 	clk->base = ioremap(phy_base, SZ_4K);
114 	if (!clk->base)
115 		goto free_clk;
116 
117 	clk->cg_sel = cg_sel;
118 	clk->is_enabled = 1;
119 
120 	clk_prcc_init.name = name;
121 	clk_prcc_init.ops = clk_prcc_ops;
122 	clk_prcc_init.flags = flags;
123 	clk_prcc_init.parent_names = (parent_name ? &parent_name : NULL);
124 	clk_prcc_init.num_parents = (parent_name ? 1 : 0);
125 	clk->hw.init = &clk_prcc_init;
126 
127 	clk_reg = clk_register(NULL, &clk->hw);
128 	if (IS_ERR_OR_NULL(clk_reg))
129 		goto unmap_clk;
130 
131 	return clk_reg;
132 
133 unmap_clk:
134 	iounmap(clk->base);
135 free_clk:
136 	kfree(clk);
137 	pr_err("clk_prcc: %s failed to register clk\n", __func__);
138 	return ERR_PTR(-ENOMEM);
139 }
140 
clk_reg_prcc_pclk(const char * name,const char * parent_name,resource_size_t phy_base,u32 cg_sel,unsigned long flags)141 struct clk *clk_reg_prcc_pclk(const char *name,
142 			      const char *parent_name,
143 			      resource_size_t phy_base,
144 			      u32 cg_sel,
145 			      unsigned long flags)
146 {
147 	return clk_reg_prcc(name, parent_name, phy_base, cg_sel, flags,
148 			&clk_prcc_pclk_ops);
149 }
150 
clk_reg_prcc_kclk(const char * name,const char * parent_name,resource_size_t phy_base,u32 cg_sel,unsigned long flags)151 struct clk *clk_reg_prcc_kclk(const char *name,
152 			      const char *parent_name,
153 			      resource_size_t phy_base,
154 			      u32 cg_sel,
155 			      unsigned long flags)
156 {
157 	return clk_reg_prcc(name, parent_name, phy_base, cg_sel, flags,
158 			&clk_prcc_kclk_ops);
159 }
160