1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Microchip Image Sensor Controller (ISC) common clock driver setup 4 * 5 * Copyright (C) 2016 Microchip Technology, Inc. 6 * 7 * Author: Songjun Wu 8 * Author: Eugen Hristev <eugen.hristev@microchip.com> 9 * 10 */ 11 #include <linux/clk.h> 12 #include <linux/clkdev.h> 13 #include <linux/clk-provider.h> 14 #include <linux/pm_runtime.h> 15 #include <linux/regmap.h> 16 17 #include "atmel-isc-regs.h" 18 #include "atmel-isc.h" 19 20 static int isc_wait_clk_stable(struct clk_hw *hw) 21 { 22 struct isc_clk *isc_clk = to_isc_clk(hw); 23 struct regmap *regmap = isc_clk->regmap; 24 unsigned long timeout = jiffies + usecs_to_jiffies(1000); 25 unsigned int status; 26 27 while (time_before(jiffies, timeout)) { 28 regmap_read(regmap, ISC_CLKSR, &status); 29 if (!(status & ISC_CLKSR_SIP)) 30 return 0; 31 32 usleep_range(10, 250); 33 } 34 35 return -ETIMEDOUT; 36 } 37 38 static int isc_clk_prepare(struct clk_hw *hw) 39 { 40 struct isc_clk *isc_clk = to_isc_clk(hw); 41 int ret; 42 43 ret = pm_runtime_resume_and_get(isc_clk->dev); 44 if (ret < 0) 45 return ret; 46 47 return isc_wait_clk_stable(hw); 48 } 49 50 static void isc_clk_unprepare(struct clk_hw *hw) 51 { 52 struct isc_clk *isc_clk = to_isc_clk(hw); 53 54 isc_wait_clk_stable(hw); 55 56 pm_runtime_put_sync(isc_clk->dev); 57 } 58 59 static int isc_clk_enable(struct clk_hw *hw) 60 { 61 struct isc_clk *isc_clk = to_isc_clk(hw); 62 u32 id = isc_clk->id; 63 struct regmap *regmap = isc_clk->regmap; 64 unsigned long flags; 65 unsigned int status; 66 67 dev_dbg(isc_clk->dev, "ISC CLK: %s, id = %d, div = %d, parent id = %d\n", 68 __func__, id, isc_clk->div, isc_clk->parent_id); 69 70 spin_lock_irqsave(&isc_clk->lock, flags); 71 regmap_update_bits(regmap, ISC_CLKCFG, 72 ISC_CLKCFG_DIV_MASK(id) | ISC_CLKCFG_SEL_MASK(id), 73 (isc_clk->div << ISC_CLKCFG_DIV_SHIFT(id)) | 74 (isc_clk->parent_id << ISC_CLKCFG_SEL_SHIFT(id))); 75 76 regmap_write(regmap, ISC_CLKEN, ISC_CLK(id)); 77 spin_unlock_irqrestore(&isc_clk->lock, flags); 78 79 regmap_read(regmap, ISC_CLKSR, &status); 80 if (status & ISC_CLK(id)) 81 return 0; 82 else 83 return -EINVAL; 84 } 85 86 static void isc_clk_disable(struct clk_hw *hw) 87 { 88 struct isc_clk *isc_clk = to_isc_clk(hw); 89 u32 id = isc_clk->id; 90 unsigned long flags; 91 92 spin_lock_irqsave(&isc_clk->lock, flags); 93 regmap_write(isc_clk->regmap, ISC_CLKDIS, ISC_CLK(id)); 94 spin_unlock_irqrestore(&isc_clk->lock, flags); 95 } 96 97 static int isc_clk_is_enabled(struct clk_hw *hw) 98 { 99 struct isc_clk *isc_clk = to_isc_clk(hw); 100 u32 status; 101 int ret; 102 103 ret = pm_runtime_resume_and_get(isc_clk->dev); 104 if (ret < 0) 105 return 0; 106 107 regmap_read(isc_clk->regmap, ISC_CLKSR, &status); 108 109 pm_runtime_put_sync(isc_clk->dev); 110 111 return status & ISC_CLK(isc_clk->id) ? 1 : 0; 112 } 113 114 static unsigned long 115 isc_clk_recalc_rate(struct clk_hw *hw, unsigned long parent_rate) 116 { 117 struct isc_clk *isc_clk = to_isc_clk(hw); 118 119 return DIV_ROUND_CLOSEST(parent_rate, isc_clk->div + 1); 120 } 121 122 static int isc_clk_determine_rate(struct clk_hw *hw, 123 struct clk_rate_request *req) 124 { 125 struct isc_clk *isc_clk = to_isc_clk(hw); 126 long best_rate = -EINVAL; 127 int best_diff = -1; 128 unsigned int i, div; 129 130 for (i = 0; i < clk_hw_get_num_parents(hw); i++) { 131 struct clk_hw *parent; 132 unsigned long parent_rate; 133 134 parent = clk_hw_get_parent_by_index(hw, i); 135 if (!parent) 136 continue; 137 138 parent_rate = clk_hw_get_rate(parent); 139 if (!parent_rate) 140 continue; 141 142 for (div = 1; div < ISC_CLK_MAX_DIV + 2; div++) { 143 unsigned long rate; 144 int diff; 145 146 rate = DIV_ROUND_CLOSEST(parent_rate, div); 147 diff = abs(req->rate - rate); 148 149 if (best_diff < 0 || best_diff > diff) { 150 best_rate = rate; 151 best_diff = diff; 152 req->best_parent_rate = parent_rate; 153 req->best_parent_hw = parent; 154 } 155 156 if (!best_diff || rate < req->rate) 157 break; 158 } 159 160 if (!best_diff) 161 break; 162 } 163 164 dev_dbg(isc_clk->dev, 165 "ISC CLK: %s, best_rate = %ld, parent clk: %s @ %ld\n", 166 __func__, best_rate, 167 __clk_get_name((req->best_parent_hw)->clk), 168 req->best_parent_rate); 169 170 if (best_rate < 0) 171 return best_rate; 172 173 req->rate = best_rate; 174 175 return 0; 176 } 177 178 static int isc_clk_set_parent(struct clk_hw *hw, u8 index) 179 { 180 struct isc_clk *isc_clk = to_isc_clk(hw); 181 182 if (index >= clk_hw_get_num_parents(hw)) 183 return -EINVAL; 184 185 isc_clk->parent_id = index; 186 187 return 0; 188 } 189 190 static u8 isc_clk_get_parent(struct clk_hw *hw) 191 { 192 struct isc_clk *isc_clk = to_isc_clk(hw); 193 194 return isc_clk->parent_id; 195 } 196 197 static int isc_clk_set_rate(struct clk_hw *hw, 198 unsigned long rate, 199 unsigned long parent_rate) 200 { 201 struct isc_clk *isc_clk = to_isc_clk(hw); 202 u32 div; 203 204 if (!rate) 205 return -EINVAL; 206 207 div = DIV_ROUND_CLOSEST(parent_rate, rate); 208 if (div > (ISC_CLK_MAX_DIV + 1) || !div) 209 return -EINVAL; 210 211 isc_clk->div = div - 1; 212 213 return 0; 214 } 215 216 static const struct clk_ops isc_clk_ops = { 217 .prepare = isc_clk_prepare, 218 .unprepare = isc_clk_unprepare, 219 .enable = isc_clk_enable, 220 .disable = isc_clk_disable, 221 .is_enabled = isc_clk_is_enabled, 222 .recalc_rate = isc_clk_recalc_rate, 223 .determine_rate = isc_clk_determine_rate, 224 .set_parent = isc_clk_set_parent, 225 .get_parent = isc_clk_get_parent, 226 .set_rate = isc_clk_set_rate, 227 }; 228 229 static int isc_clk_register(struct isc_device *isc, unsigned int id) 230 { 231 struct regmap *regmap = isc->regmap; 232 struct device_node *np = isc->dev->of_node; 233 struct isc_clk *isc_clk; 234 struct clk_init_data init; 235 const char *clk_name = np->name; 236 const char *parent_names[3]; 237 int num_parents; 238 239 if (id == ISC_ISPCK && !isc->ispck_required) 240 return 0; 241 242 num_parents = of_clk_get_parent_count(np); 243 if (num_parents < 1 || num_parents > 3) 244 return -EINVAL; 245 246 if (num_parents > 2 && id == ISC_ISPCK) 247 num_parents = 2; 248 249 of_clk_parent_fill(np, parent_names, num_parents); 250 251 if (id == ISC_MCK) 252 of_property_read_string(np, "clock-output-names", &clk_name); 253 else 254 clk_name = "isc-ispck"; 255 256 init.parent_names = parent_names; 257 init.num_parents = num_parents; 258 init.name = clk_name; 259 init.ops = &isc_clk_ops; 260 init.flags = CLK_SET_RATE_GATE | CLK_SET_PARENT_GATE; 261 262 isc_clk = &isc->isc_clks[id]; 263 isc_clk->hw.init = &init; 264 isc_clk->regmap = regmap; 265 isc_clk->id = id; 266 isc_clk->dev = isc->dev; 267 spin_lock_init(&isc_clk->lock); 268 269 isc_clk->clk = clk_register(isc->dev, &isc_clk->hw); 270 if (IS_ERR(isc_clk->clk)) { 271 dev_err(isc->dev, "%s: clock register fail\n", clk_name); 272 return PTR_ERR(isc_clk->clk); 273 } else if (id == ISC_MCK) { 274 of_clk_add_provider(np, of_clk_src_simple_get, isc_clk->clk); 275 } 276 277 return 0; 278 } 279 280 int atmel_isc_clk_init(struct isc_device *isc) 281 { 282 unsigned int i; 283 int ret; 284 285 for (i = 0; i < ARRAY_SIZE(isc->isc_clks); i++) 286 isc->isc_clks[i].clk = ERR_PTR(-EINVAL); 287 288 for (i = 0; i < ARRAY_SIZE(isc->isc_clks); i++) { 289 ret = isc_clk_register(isc, i); 290 if (ret) 291 return ret; 292 } 293 294 return 0; 295 } 296 EXPORT_SYMBOL_GPL(atmel_isc_clk_init); 297 298 void atmel_isc_clk_cleanup(struct isc_device *isc) 299 { 300 unsigned int i; 301 302 of_clk_del_provider(isc->dev->of_node); 303 304 for (i = 0; i < ARRAY_SIZE(isc->isc_clks); i++) { 305 struct isc_clk *isc_clk = &isc->isc_clks[i]; 306 307 if (!IS_ERR(isc_clk->clk)) 308 clk_unregister(isc_clk->clk); 309 } 310 } 311 EXPORT_SYMBOL_GPL(atmel_isc_clk_cleanup); 312