xref: /linux/drivers/clk/qcom/clk-branch.c (revision a1ff5a7d78a036d6c2178ee5acd6ba4946243800)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2013, The Linux Foundation. All rights reserved.
4  * Copyright (c) 2023, Qualcomm Innovation Center, Inc. All rights reserved.
5  */
6 
7 #include <linux/kernel.h>
8 #include <linux/bitops.h>
9 #include <linux/err.h>
10 #include <linux/delay.h>
11 #include <linux/export.h>
12 #include <linux/clk-provider.h>
13 #include <linux/regmap.h>
14 
15 #include "clk-branch.h"
16 
clk_branch_in_hwcg_mode(const struct clk_branch * br)17 static bool clk_branch_in_hwcg_mode(const struct clk_branch *br)
18 {
19 	u32 val;
20 
21 	if (!br->hwcg_reg)
22 		return false;
23 
24 	regmap_read(br->clkr.regmap, br->hwcg_reg, &val);
25 
26 	return !!(val & BIT(br->hwcg_bit));
27 }
28 
clk_branch_check_halt(const struct clk_branch * br,bool enabling)29 static bool clk_branch_check_halt(const struct clk_branch *br, bool enabling)
30 {
31 	bool invert = (br->halt_check == BRANCH_HALT_ENABLE);
32 	u32 val;
33 
34 	regmap_read(br->clkr.regmap, br->halt_reg, &val);
35 
36 	val &= BIT(br->halt_bit);
37 	if (invert)
38 		val = !val;
39 
40 	return !!val == !enabling;
41 }
42 
clk_branch2_check_halt(const struct clk_branch * br,bool enabling)43 static bool clk_branch2_check_halt(const struct clk_branch *br, bool enabling)
44 {
45 	u32 val;
46 	u32 mask;
47 	bool invert = (br->halt_check == BRANCH_HALT_ENABLE);
48 
49 	mask = CBCR_NOC_FSM_STATUS;
50 	mask |= CBCR_CLK_OFF;
51 
52 	regmap_read(br->clkr.regmap, br->halt_reg, &val);
53 
54 	if (enabling) {
55 		val &= mask;
56 		return (val & CBCR_CLK_OFF) == (invert ? CBCR_CLK_OFF : 0) ||
57 			FIELD_GET(CBCR_NOC_FSM_STATUS, val) == FSM_STATUS_ON;
58 	}
59 	return (val & CBCR_CLK_OFF) == (invert ? 0 : CBCR_CLK_OFF);
60 }
61 
clk_branch_wait(const struct clk_branch * br,bool enabling,bool (check_halt)(const struct clk_branch *,bool))62 static int clk_branch_wait(const struct clk_branch *br, bool enabling,
63 		bool (check_halt)(const struct clk_branch *, bool))
64 {
65 	bool voted = br->halt_check & BRANCH_VOTED;
66 	const char *name = clk_hw_get_name(&br->clkr.hw);
67 
68 	/*
69 	 * Skip checking halt bit if we're explicitly ignoring the bit or the
70 	 * clock is in hardware gated mode
71 	 */
72 	if (br->halt_check == BRANCH_HALT_SKIP || clk_branch_in_hwcg_mode(br))
73 		return 0;
74 
75 	if (br->halt_check == BRANCH_HALT_DELAY || (!enabling && voted)) {
76 		udelay(10);
77 	} else if (br->halt_check == BRANCH_HALT_ENABLE ||
78 		   br->halt_check == BRANCH_HALT ||
79 		   (enabling && voted)) {
80 		int count = 200;
81 
82 		while (count-- > 0) {
83 			if (check_halt(br, enabling))
84 				return 0;
85 			udelay(1);
86 		}
87 		WARN(1, "%s status stuck at 'o%s'", name,
88 				enabling ? "ff" : "n");
89 		return -EBUSY;
90 	}
91 	return 0;
92 }
93 
clk_branch_toggle(struct clk_hw * hw,bool en,bool (check_halt)(const struct clk_branch *,bool))94 static int clk_branch_toggle(struct clk_hw *hw, bool en,
95 		bool (check_halt)(const struct clk_branch *, bool))
96 {
97 	struct clk_branch *br = to_clk_branch(hw);
98 	int ret;
99 
100 	if (en) {
101 		ret = clk_enable_regmap(hw);
102 		if (ret)
103 			return ret;
104 	} else {
105 		clk_disable_regmap(hw);
106 	}
107 
108 	return clk_branch_wait(br, en, check_halt);
109 }
110 
clk_branch_enable(struct clk_hw * hw)111 static int clk_branch_enable(struct clk_hw *hw)
112 {
113 	return clk_branch_toggle(hw, true, clk_branch_check_halt);
114 }
115 
clk_branch_disable(struct clk_hw * hw)116 static void clk_branch_disable(struct clk_hw *hw)
117 {
118 	clk_branch_toggle(hw, false, clk_branch_check_halt);
119 }
120 
121 const struct clk_ops clk_branch_ops = {
122 	.enable = clk_branch_enable,
123 	.disable = clk_branch_disable,
124 	.is_enabled = clk_is_enabled_regmap,
125 };
126 EXPORT_SYMBOL_GPL(clk_branch_ops);
127 
clk_branch2_enable(struct clk_hw * hw)128 static int clk_branch2_enable(struct clk_hw *hw)
129 {
130 	return clk_branch_toggle(hw, true, clk_branch2_check_halt);
131 }
132 
clk_branch2_disable(struct clk_hw * hw)133 static void clk_branch2_disable(struct clk_hw *hw)
134 {
135 	clk_branch_toggle(hw, false, clk_branch2_check_halt);
136 }
137 
clk_branch2_mem_enable(struct clk_hw * hw)138 static int clk_branch2_mem_enable(struct clk_hw *hw)
139 {
140 	struct clk_mem_branch *mem_br = to_clk_mem_branch(hw);
141 	struct clk_branch branch = mem_br->branch;
142 	u32 val;
143 	int ret;
144 
145 	regmap_update_bits(branch.clkr.regmap, mem_br->mem_enable_reg,
146 			   mem_br->mem_enable_ack_mask, mem_br->mem_enable_ack_mask);
147 
148 	ret = regmap_read_poll_timeout(branch.clkr.regmap, mem_br->mem_ack_reg,
149 				       val, val & mem_br->mem_enable_ack_mask, 0, 200);
150 	if (ret) {
151 		WARN(1, "%s mem enable failed\n", clk_hw_get_name(&branch.clkr.hw));
152 		return ret;
153 	}
154 
155 	return clk_branch2_enable(hw);
156 }
157 
clk_branch2_mem_disable(struct clk_hw * hw)158 static void clk_branch2_mem_disable(struct clk_hw *hw)
159 {
160 	struct clk_mem_branch *mem_br = to_clk_mem_branch(hw);
161 
162 	regmap_update_bits(mem_br->branch.clkr.regmap, mem_br->mem_enable_reg,
163 			   mem_br->mem_enable_ack_mask, 0);
164 
165 	return clk_branch2_disable(hw);
166 }
167 
168 const struct clk_ops clk_branch2_mem_ops = {
169 	.enable = clk_branch2_mem_enable,
170 	.disable = clk_branch2_mem_disable,
171 	.is_enabled = clk_is_enabled_regmap,
172 };
173 EXPORT_SYMBOL_GPL(clk_branch2_mem_ops);
174 
175 const struct clk_ops clk_branch2_ops = {
176 	.enable = clk_branch2_enable,
177 	.disable = clk_branch2_disable,
178 	.is_enabled = clk_is_enabled_regmap,
179 };
180 EXPORT_SYMBOL_GPL(clk_branch2_ops);
181 
182 const struct clk_ops clk_branch2_aon_ops = {
183 	.enable = clk_branch2_enable,
184 	.is_enabled = clk_is_enabled_regmap,
185 };
186 EXPORT_SYMBOL_GPL(clk_branch2_aon_ops);
187 
188 const struct clk_ops clk_branch_simple_ops = {
189 	.enable = clk_enable_regmap,
190 	.disable = clk_disable_regmap,
191 	.is_enabled = clk_is_enabled_regmap,
192 };
193 EXPORT_SYMBOL_GPL(clk_branch_simple_ops);
194 
195 const struct clk_ops clk_branch2_prepare_ops = {
196 	.prepare = clk_branch2_enable,
197 	.unprepare = clk_branch2_disable,
198 	.is_prepared = clk_is_enabled_regmap,
199 };
200 EXPORT_SYMBOL_GPL(clk_branch2_prepare_ops);
201