1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2013 Broadcom Corporation. 4 */ 5 6 /* 7 * 8 * bcm281xx architecture clock framework 9 * 10 */ 11 12 #include <common.h> 13 #include <asm/io.h> 14 #include <linux/errno.h> 15 #include <bitfield.h> 16 #include <asm/arch/sysmap.h> 17 #include <asm/kona-common/clk.h> 18 #include "clk-core.h" 19 20 #define CLK_WR_ACCESS_PASSWORD 0x00a5a501 21 #define WR_ACCESS_OFFSET 0 /* common to all clock blocks */ 22 #define POLICY_CTL_GO 1 /* Load and refresh policy masks */ 23 #define POLICY_CTL_GO_ATL 4 /* Active Load */ 24 25 /* Helper function */ 26 int clk_get_and_enable(char *clkstr) 27 { 28 int ret = 0; 29 struct clk *c; 30 31 debug("%s: %s\n", __func__, clkstr); 32 33 c = clk_get(clkstr); 34 if (c) { 35 ret = clk_enable(c); 36 if (ret) 37 return ret; 38 } else { 39 printf("%s: Couldn't find %s\n", __func__, clkstr); 40 return -EINVAL; 41 } 42 return ret; 43 } 44 45 /* 46 * Poll a register in a CCU's address space, returning when the 47 * specified bit in that register's value is set (or clear). Delay 48 * a microsecond after each read of the register. Returns true if 49 * successful, or false if we gave up trying. 50 * 51 * Caller must ensure the CCU lock is held. 52 */ 53 #define CLK_GATE_DELAY_USEC 2000 54 static inline int wait_bit(void *base, u32 offset, u32 bit, bool want) 55 { 56 unsigned int tries; 57 u32 bit_mask = 1 << bit; 58 59 for (tries = 0; tries < CLK_GATE_DELAY_USEC; tries++) { 60 u32 val; 61 bool bit_val; 62 63 val = readl(base + offset); 64 bit_val = (val & bit_mask) ? 1 : 0; 65 if (bit_val == want) 66 return 0; /* success */ 67 udelay(1); 68 } 69 70 debug("%s: timeout on addr 0x%p, waiting for bit %d to go to %d\n", 71 __func__, base + offset, bit, want); 72 73 return -ETIMEDOUT; 74 } 75 76 /* Enable a peripheral clock */ 77 static int peri_clk_enable(struct clk *c, int enable) 78 { 79 int ret = 0; 80 u32 reg; 81 struct peri_clock *peri_clk = to_peri_clk(c); 82 struct peri_clk_data *cd = peri_clk->data; 83 struct bcm_clk_gate *gate = &cd->gate; 84 void *base = (void *)c->ccu_clk_mgr_base; 85 86 87 debug("%s: %s\n", __func__, c->name); 88 89 clk_get_rate(c); /* Make sure rate and sel are filled in */ 90 91 /* enable access */ 92 writel(CLK_WR_ACCESS_PASSWORD, base + WR_ACCESS_OFFSET); 93 94 if (enable) { 95 debug("%s %s set rate %lu div %lu sel %d parent %lu\n", 96 __func__, c->name, c->rate, c->div, c->sel, 97 c->parent->rate); 98 99 /* 100 * clkgate - only software controllable gates are 101 * supported by u-boot which includes all clocks 102 * that matter. This avoids bringing in a lot of extra 103 * complexity as done in the kernel framework. 104 */ 105 if (gate_exists(gate)) { 106 reg = readl(base + cd->gate.offset); 107 reg |= (1 << cd->gate.en_bit); 108 writel(reg, base + cd->gate.offset); 109 } 110 111 /* div and pll select */ 112 if (divider_exists(&cd->div)) { 113 reg = readl(base + cd->div.offset); 114 bitfield_replace(reg, cd->div.shift, cd->div.width, 115 c->div - 1); 116 writel(reg, base + cd->div.offset); 117 } 118 119 /* frequency selector */ 120 if (selector_exists(&cd->sel)) { 121 reg = readl(base + cd->sel.offset); 122 bitfield_replace(reg, cd->sel.shift, cd->sel.width, 123 c->sel); 124 writel(reg, base + cd->sel.offset); 125 } 126 127 /* trigger */ 128 if (trigger_exists(&cd->trig)) { 129 writel((1 << cd->trig.bit), base + cd->trig.offset); 130 131 /* wait for trigger status bit to go to 0 */ 132 ret = wait_bit(base, cd->trig.offset, cd->trig.bit, 0); 133 if (ret) 134 return ret; 135 } 136 137 /* wait for running (status_bit = 1) */ 138 ret = wait_bit(base, cd->gate.offset, cd->gate.status_bit, 1); 139 if (ret) 140 return ret; 141 } else { 142 debug("%s disable clock %s\n", __func__, c->name); 143 144 /* clkgate */ 145 reg = readl(base + cd->gate.offset); 146 reg &= ~(1 << cd->gate.en_bit); 147 writel(reg, base + cd->gate.offset); 148 149 /* wait for stop (status_bit = 0) */ 150 ret = wait_bit(base, cd->gate.offset, cd->gate.status_bit, 0); 151 } 152 153 /* disable access */ 154 writel(0, base + WR_ACCESS_OFFSET); 155 156 return ret; 157 } 158 159 /* Set the rate of a peripheral clock */ 160 static int peri_clk_set_rate(struct clk *c, unsigned long rate) 161 { 162 int ret = 0; 163 int i; 164 unsigned long diff; 165 unsigned long new_rate = 0, div = 1; 166 struct peri_clock *peri_clk = to_peri_clk(c); 167 struct peri_clk_data *cd = peri_clk->data; 168 const char **clock; 169 170 debug("%s: %s\n", __func__, c->name); 171 diff = rate; 172 173 i = 0; 174 for (clock = cd->clocks; *clock; clock++, i++) { 175 struct refclk *ref = refclk_str_to_clk(*clock); 176 if (!ref) { 177 printf("%s: Lookup of %s failed\n", __func__, *clock); 178 return -EINVAL; 179 } 180 181 /* round to the new rate */ 182 div = ref->clk.rate / rate; 183 if (div == 0) 184 div = 1; 185 186 new_rate = ref->clk.rate / div; 187 188 /* get the min diff */ 189 if (abs(new_rate - rate) < diff) { 190 diff = abs(new_rate - rate); 191 c->sel = i; 192 c->parent = &ref->clk; 193 c->rate = new_rate; 194 c->div = div; 195 } 196 } 197 198 debug("%s %s set rate %lu div %lu sel %d parent %lu\n", __func__, 199 c->name, c->rate, c->div, c->sel, c->parent->rate); 200 return ret; 201 } 202 203 /* Get the rate of a peripheral clock */ 204 static unsigned long peri_clk_get_rate(struct clk *c) 205 { 206 struct peri_clock *peri_clk = to_peri_clk(c); 207 struct peri_clk_data *cd = peri_clk->data; 208 void *base = (void *)c->ccu_clk_mgr_base; 209 int div = 1; 210 const char **clock; 211 struct refclk *ref; 212 u32 reg; 213 214 debug("%s: %s\n", __func__, c->name); 215 if (selector_exists(&cd->sel)) { 216 reg = readl(base + cd->sel.offset); 217 c->sel = bitfield_extract(reg, cd->sel.shift, cd->sel.width); 218 } else { 219 /* 220 * For peri clocks that don't have a selector, the single 221 * reference clock will always exist at index 0. 222 */ 223 c->sel = 0; 224 } 225 226 if (divider_exists(&cd->div)) { 227 reg = readl(base + cd->div.offset); 228 div = bitfield_extract(reg, cd->div.shift, cd->div.width); 229 div += 1; 230 } 231 232 clock = cd->clocks; 233 ref = refclk_str_to_clk(clock[c->sel]); 234 if (!ref) { 235 printf("%s: Can't lookup %s\n", __func__, clock[c->sel]); 236 return 0; 237 } 238 239 c->parent = &ref->clk; 240 c->div = div; 241 c->rate = c->parent->rate / c->div; 242 debug("%s parent rate %lu div %d sel %d rate %lu\n", __func__, 243 c->parent->rate, div, c->sel, c->rate); 244 245 return c->rate; 246 } 247 248 /* Peripheral clock operations */ 249 struct clk_ops peri_clk_ops = { 250 .enable = peri_clk_enable, 251 .set_rate = peri_clk_set_rate, 252 .get_rate = peri_clk_get_rate, 253 }; 254 255 /* Enable a CCU clock */ 256 static int ccu_clk_enable(struct clk *c, int enable) 257 { 258 struct ccu_clock *ccu_clk = to_ccu_clk(c); 259 void *base = (void *)c->ccu_clk_mgr_base; 260 int ret = 0; 261 u32 reg; 262 263 debug("%s: %s\n", __func__, c->name); 264 if (!enable) 265 return -EINVAL; /* CCU clock cannot shutdown */ 266 267 /* enable access */ 268 writel(CLK_WR_ACCESS_PASSWORD, base + WR_ACCESS_OFFSET); 269 270 /* config enable for policy engine */ 271 writel(1, base + ccu_clk->lvm_en_offset); 272 273 /* wait for bit to go to 0 */ 274 ret = wait_bit(base, ccu_clk->lvm_en_offset, 0, 0); 275 if (ret) 276 return ret; 277 278 /* freq ID */ 279 if (!ccu_clk->freq_bit_shift) 280 ccu_clk->freq_bit_shift = 8; 281 282 /* Set frequency id for each of the 4 policies */ 283 reg = ccu_clk->freq_id | 284 (ccu_clk->freq_id << (ccu_clk->freq_bit_shift)) | 285 (ccu_clk->freq_id << (ccu_clk->freq_bit_shift * 2)) | 286 (ccu_clk->freq_id << (ccu_clk->freq_bit_shift * 3)); 287 writel(reg, base + ccu_clk->policy_freq_offset); 288 289 /* enable all clock mask */ 290 writel(0x7fffffff, base + ccu_clk->policy0_mask_offset); 291 writel(0x7fffffff, base + ccu_clk->policy1_mask_offset); 292 writel(0x7fffffff, base + ccu_clk->policy2_mask_offset); 293 writel(0x7fffffff, base + ccu_clk->policy3_mask_offset); 294 295 if (ccu_clk->num_policy_masks == 2) { 296 writel(0x7fffffff, base + ccu_clk->policy0_mask2_offset); 297 writel(0x7fffffff, base + ccu_clk->policy1_mask2_offset); 298 writel(0x7fffffff, base + ccu_clk->policy2_mask2_offset); 299 writel(0x7fffffff, base + ccu_clk->policy3_mask2_offset); 300 } 301 302 /* start policy engine */ 303 reg = readl(base + ccu_clk->policy_ctl_offset); 304 reg |= (POLICY_CTL_GO + POLICY_CTL_GO_ATL); 305 writel(reg, base + ccu_clk->policy_ctl_offset); 306 307 /* wait till started */ 308 ret = wait_bit(base, ccu_clk->policy_ctl_offset, 0, 0); 309 if (ret) 310 return ret; 311 312 /* disable access */ 313 writel(0, base + WR_ACCESS_OFFSET); 314 315 return ret; 316 } 317 318 /* Get the CCU clock rate */ 319 static unsigned long ccu_clk_get_rate(struct clk *c) 320 { 321 struct ccu_clock *ccu_clk = to_ccu_clk(c); 322 debug("%s: %s\n", __func__, c->name); 323 c->rate = ccu_clk->freq_tbl[ccu_clk->freq_id]; 324 return c->rate; 325 } 326 327 /* CCU clock operations */ 328 struct clk_ops ccu_clk_ops = { 329 .enable = ccu_clk_enable, 330 .get_rate = ccu_clk_get_rate, 331 }; 332 333 /* Enable a bus clock */ 334 static int bus_clk_enable(struct clk *c, int enable) 335 { 336 struct bus_clock *bus_clk = to_bus_clk(c); 337 struct bus_clk_data *cd = bus_clk->data; 338 void *base = (void *)c->ccu_clk_mgr_base; 339 int ret = 0; 340 u32 reg; 341 342 debug("%s: %s\n", __func__, c->name); 343 /* enable access */ 344 writel(CLK_WR_ACCESS_PASSWORD, base + WR_ACCESS_OFFSET); 345 346 /* enable gating */ 347 reg = readl(base + cd->gate.offset); 348 if (!!(reg & (1 << cd->gate.status_bit)) == !!enable) 349 debug("%s already %s\n", c->name, 350 enable ? "enabled" : "disabled"); 351 else { 352 int want = (enable) ? 1 : 0; 353 reg |= (1 << cd->gate.hw_sw_sel_bit); 354 355 if (enable) 356 reg |= (1 << cd->gate.en_bit); 357 else 358 reg &= ~(1 << cd->gate.en_bit); 359 360 writel(reg, base + cd->gate.offset); 361 ret = wait_bit(base, cd->gate.offset, cd->gate.status_bit, 362 want); 363 if (ret) 364 return ret; 365 } 366 367 /* disable access */ 368 writel(0, base + WR_ACCESS_OFFSET); 369 370 return ret; 371 } 372 373 /* Get the rate of a bus clock */ 374 static unsigned long bus_clk_get_rate(struct clk *c) 375 { 376 struct bus_clock *bus_clk = to_bus_clk(c); 377 struct ccu_clock *ccu_clk; 378 379 debug("%s: %s\n", __func__, c->name); 380 ccu_clk = to_ccu_clk(c->parent); 381 382 c->rate = bus_clk->freq_tbl[ccu_clk->freq_id]; 383 c->div = ccu_clk->freq_tbl[ccu_clk->freq_id] / c->rate; 384 return c->rate; 385 } 386 387 /* Bus clock operations */ 388 struct clk_ops bus_clk_ops = { 389 .enable = bus_clk_enable, 390 .get_rate = bus_clk_get_rate, 391 }; 392 393 /* Enable a reference clock */ 394 static int ref_clk_enable(struct clk *c, int enable) 395 { 396 debug("%s: %s\n", __func__, c->name); 397 return 0; 398 } 399 400 /* Reference clock operations */ 401 struct clk_ops ref_clk_ops = { 402 .enable = ref_clk_enable, 403 }; 404 405 /* 406 * clk.h implementation follows 407 */ 408 409 /* Initialize the clock framework */ 410 int clk_init(void) 411 { 412 debug("%s:\n", __func__); 413 return 0; 414 } 415 416 /* Get a clock handle, give a name string */ 417 struct clk *clk_get(const char *con_id) 418 { 419 int i; 420 struct clk_lookup *clk_tblp; 421 422 debug("%s: %s\n", __func__, con_id); 423 424 clk_tblp = arch_clk_tbl; 425 for (i = 0; i < arch_clk_tbl_array_size; i++, clk_tblp++) { 426 if (clk_tblp->con_id) { 427 if (!con_id || strcmp(clk_tblp->con_id, con_id)) 428 continue; 429 return clk_tblp->clk; 430 } 431 } 432 return NULL; 433 } 434 435 /* Enable a clock */ 436 int clk_enable(struct clk *c) 437 { 438 int ret = 0; 439 440 debug("%s: %s\n", __func__, c->name); 441 if (!c->ops || !c->ops->enable) 442 return -1; 443 444 /* enable parent clock first */ 445 if (c->parent) 446 ret = clk_enable(c->parent); 447 448 if (ret) 449 return ret; 450 451 if (!c->use_cnt) { 452 c->use_cnt++; 453 ret = c->ops->enable(c, 1); 454 } 455 456 return ret; 457 } 458 459 /* Disable a clock */ 460 void clk_disable(struct clk *c) 461 { 462 debug("%s: %s\n", __func__, c->name); 463 if (!c->ops || !c->ops->enable) 464 return; 465 466 if (c->use_cnt) { 467 c->use_cnt--; 468 c->ops->enable(c, 0); 469 } 470 471 /* disable parent */ 472 if (c->parent) 473 clk_disable(c->parent); 474 } 475 476 /* Get the clock rate */ 477 unsigned long clk_get_rate(struct clk *c) 478 { 479 unsigned long rate; 480 481 if (!c || !c->ops || !c->ops->get_rate) 482 return 0; 483 debug("%s: %s\n", __func__, c->name); 484 485 rate = c->ops->get_rate(c); 486 debug("%s: rate = %ld\n", __func__, rate); 487 return rate; 488 } 489 490 /* Set the clock rate */ 491 int clk_set_rate(struct clk *c, unsigned long rate) 492 { 493 int ret; 494 495 if (!c || !c->ops || !c->ops->set_rate) 496 return -EINVAL; 497 debug("%s: %s rate=%ld\n", __func__, c->name, rate); 498 499 if (c->use_cnt) 500 return -EINVAL; 501 502 ret = c->ops->set_rate(c, rate); 503 504 return ret; 505 } 506 507 /* Not required for this arch */ 508 /* 509 long clk_round_rate(struct clk *clk, unsigned long rate); 510 int clk_set_parent(struct clk *clk, struct clk *parent); 511 struct clk *clk_get_parent(struct clk *clk); 512 */ 513