17  * CCU.  (I believe these polices are named "Deep Sleep", "Economy",
120 /* CCU access */
122 /* Read a 32-bit register value from a CCU's address space. */
123 static inline u32 __ccu_read(struct ccu_data *ccu, u32 reg_offset)  in __ccu_read()  argument
125 	return readl(ccu->base + reg_offset);  in __ccu_read()
128 /* Write a 32-bit register value into a CCU's address space. */
130 __ccu_write(struct ccu_data *ccu, u32 reg_offset, u32 reg_val)  in __ccu_write()  argument
132 	writel(reg_val, ccu->base + reg_offset);  in __ccu_write()
135 static inline unsigned long ccu_lock(struct ccu_data *ccu)  in ccu_lock()  argument
139 	spin_lock_irqsave(&ccu->lock, flags);  in ccu_lock()
143 static inline void ccu_unlock(struct ccu_data *ccu, unsigned long flags)  in ccu_unlock()  argument
145 	spin_unlock_irqrestore(&ccu->lock, flags);  in ccu_unlock()
149  * Enable/disable write access to CCU protected registers.  The
152 static inline void __ccu_write_enable(struct ccu_data *ccu)  in __ccu_write_enable()  argument
154 	if (ccu->write_enabled) {  in __ccu_write_enable()
156 			ccu->name);  in __ccu_write_enable()
159 	ccu->write_enabled = true;  in __ccu_write_enable()
160 	__ccu_write(ccu, 0, CCU_ACCESS_PASSWORD | 1);  in __ccu_write_enable()
163 static inline void __ccu_write_disable(struct ccu_data *ccu)  in __ccu_write_disable()  argument
165 	if (!ccu->write_enabled) {  in __ccu_write_disable()
167 			ccu->name);  in __ccu_write_disable()
171 	__ccu_write(ccu, 0, CCU_ACCESS_PASSWORD);  in __ccu_write_disable()
172 	ccu->write_enabled = false;  in __ccu_write_disable()
176  * Poll a register in a CCU's address space, returning when the
181  * Caller must ensure the CCU lock is held.
184 __ccu_wait_bit(struct ccu_data *ccu, u32 reg_offset, u32 bit, bool want)  in __ccu_wait_bit()  argument
193 		val = __ccu_read(ccu, reg_offset);  in __ccu_wait_bit()
200 		ccu->name, reg_offset, bit, want ? "set" : "clear");  in __ccu_wait_bit()
207 static bool __ccu_policy_engine_start(struct ccu_data *ccu, bool sync)  in __ccu_policy_engine_start()  argument
209 	struct bcm_policy_ctl *control = &ccu->policy.control;  in __ccu_policy_engine_start()
215 	/* If we don't need to control policy for this CCU, we're done. */  in __ccu_policy_engine_start()
223 	ret = __ccu_wait_bit(ccu, offset, go_bit, false);  in __ccu_policy_engine_start()
225 		pr_err("%s: ccu %s policy engine wouldn't go idle\n",  in __ccu_policy_engine_start()
226 			__func__, ccu->name);  in __ccu_policy_engine_start()
238 	 * load is copied to the active load and the CCU frequency  in __ccu_policy_engine_start()
250 	__ccu_write(ccu, offset, mask);  in __ccu_policy_engine_start()
253 	ret = __ccu_wait_bit(ccu, offset, go_bit, false);  in __ccu_policy_engine_start()
255 		pr_err("%s: ccu %s policy engine never started\n",  in __ccu_policy_engine_start()
256 			__func__, ccu->name);  in __ccu_policy_engine_start()
261 static bool __ccu_policy_engine_stop(struct ccu_data *ccu)  in __ccu_policy_engine_stop()  argument
263 	struct bcm_lvm_en *enable = &ccu->policy.enable;  in __ccu_policy_engine_stop()
268 	/* If we don't need to control policy for this CCU, we're done. */  in __ccu_policy_engine_stop()
275 	ret = __ccu_wait_bit(ccu, offset, enable_bit, false);  in __ccu_policy_engine_stop()
277 		pr_err("%s: ccu %s policy engine already stopped\n",  in __ccu_policy_engine_stop()
278 			__func__, ccu->name);  in __ccu_policy_engine_stop()
283 	__ccu_write(ccu, offset, (u32)1 << enable_bit);  in __ccu_policy_engine_stop()
286 	ret = __ccu_wait_bit(ccu, offset, enable_bit, false);  in __ccu_policy_engine_stop()
288 		pr_err("%s: ccu %s policy engine never stopped\n",  in __ccu_policy_engine_stop()
289 			__func__, ccu->name);  in __ccu_policy_engine_stop()
295  * A CCU has four operating conditions ("policies"), and some clocks
303 static bool policy_init(struct ccu_data *ccu, struct bcm_clk_policy *policy)  in policy_init()  argument
314 	 * We need to stop the CCU policy engine to allow update  in policy_init()
317 	if (!__ccu_policy_engine_stop(ccu)) {  in policy_init()
318 		pr_err("%s: unable to stop CCU %s policy engine\n",  in policy_init()
319 			__func__, ccu->name);  in policy_init()
332 		reg_val = __ccu_read(ccu, offset);  in policy_init()
334 		__ccu_write(ccu, offset, reg_val);  in policy_init()
339 	ret = __ccu_policy_engine_start(ccu, true);  in policy_init()
341 		pr_err("%s: unable to restart CCU %s policy engine\n",  in policy_init()
342 			__func__, ccu->name);  in policy_init()
349 /* Determine whether a clock is gated.  CCU lock must be held.  */
351 __is_clk_gate_enabled(struct ccu_data *ccu, struct bcm_clk_gate *gate)  in __is_clk_gate_enabled()  argument
361 	reg_val = __ccu_read(ccu, gate->offset);  in __is_clk_gate_enabled()
368 is_clk_gate_enabled(struct ccu_data *ccu, struct bcm_clk_gate *gate)  in is_clk_gate_enabled()  argument
377 	flags = ccu_lock(ccu);  in is_clk_gate_enabled()
378 	ret = __is_clk_gate_enabled(ccu, gate);  in is_clk_gate_enabled()
379 	ccu_unlock(ccu, flags);  in is_clk_gate_enabled()
389 __gate_commit(struct ccu_data *ccu, struct bcm_clk_gate *gate)  in __gate_commit()  argument
399 	reg_val = __ccu_read(ccu, gate->offset);  in __gate_commit()
424 	__ccu_write(ccu, gate->offset, reg_val);  in __gate_commit()
431 	return __ccu_wait_bit(ccu, gate->offset, gate->status_bit, enabled);  in __gate_commit()
440 static bool gate_init(struct ccu_data *ccu, struct bcm_clk_gate *gate)  in gate_init()  argument
444 	return __gate_commit(ccu, gate);  in gate_init()
451  * otherwise.  CCU lock must be held.
454 __clk_gate(struct ccu_data *ccu, struct bcm_clk_gate *gate, bool enable)  in __clk_gate()  argument
471 	ret = __gate_commit(ccu, gate);  in __clk_gate()
479 static int clk_gate(struct ccu_data *ccu, const char *name,  in clk_gate()  argument
494 	flags = ccu_lock(ccu);  in clk_gate()
495 	__ccu_write_enable(ccu);  in clk_gate()
497 	success = __clk_gate(ccu, gate, enable);  in clk_gate()
499 	__ccu_write_disable(ccu);  in clk_gate()
500 	ccu_unlock(ccu, flags);  in clk_gate()
520 static bool hyst_init(struct ccu_data *ccu, struct bcm_clk_hyst *hyst)  in hyst_init()  argument
533 	reg_val = __ccu_read(ccu, offset);  in hyst_init()
535 	__ccu_write(ccu, offset, reg_val);  in hyst_init()
543  * Caller must ensure CCU lock is held and access is enabled.
546 static bool __clk_trigger(struct ccu_data *ccu, struct bcm_clk_trig *trig)  in __clk_trigger()  argument
549 	__ccu_write(ccu, trig->offset, 1 << trig->bit);  in __clk_trigger()
551 	return __ccu_wait_bit(ccu, trig->offset, trig->bit, false);  in __clk_trigger()
557 static u64 divider_read_scaled(struct ccu_data *ccu, struct bcm_clk_div *div)  in divider_read_scaled()  argument
566 	flags = ccu_lock(ccu);  in divider_read_scaled()
567 	reg_val = __ccu_read(ccu, div->u.s.offset);  in divider_read_scaled()
568 	ccu_unlock(ccu, flags);  in divider_read_scaled()
584 static int __div_commit(struct ccu_data *ccu, struct bcm_clk_gate *gate,  in __div_commit()  argument
600 		reg_val = __ccu_read(ccu, div->u.s.offset);  in __div_commit()
612 	enabled = __is_clk_gate_enabled(ccu, gate);  in __div_commit()
613 	if (!enabled && !__clk_gate(ccu, gate, true)) {  in __div_commit()
619 	reg_val = __ccu_read(ccu, div->u.s.offset);  in __div_commit()
622 	__ccu_write(ccu, div->u.s.offset, reg_val);  in __div_commit()
625 	if (!__clk_trigger(ccu, trig))  in __div_commit()
629 	if (!enabled && !__clk_gate(ccu, gate, false))  in __div_commit()
640 static bool div_init(struct ccu_data *ccu, struct bcm_clk_gate *gate,  in div_init()  argument
645 	return !__div_commit(ccu, gate, div, trig);  in div_init()
648 static int divider_write(struct ccu_data *ccu, struct bcm_clk_gate *gate,  in divider_write()  argument
664 	flags = ccu_lock(ccu);  in divider_write()
665 	__ccu_write_enable(ccu);  in divider_write()
667 	ret = __div_commit(ccu, gate, div, trig);  in divider_write()
669 	__ccu_write_disable(ccu);  in divider_write()
670 	ccu_unlock(ccu, flags);  in divider_write()
686 static unsigned long clk_recalc_rate(struct ccu_data *ccu,  in clk_recalc_rate()  argument
714 		scaled_div = divider_read_scaled(ccu, pre_div);  in clk_recalc_rate()
726 	scaled_div = divider_read_scaled(ccu, div);  in clk_recalc_rate()
741 static long round_rate(struct ccu_data *ccu, struct bcm_clk_div *div,  in round_rate()  argument
773 		scaled_pre_div = divider_read_scaled(ccu, pre_div);  in round_rate()
795 		best_scaled_div = divider_read_scaled(ccu, div);  in round_rate()
833 static u8 selector_read_index(struct ccu_data *ccu, struct bcm_clk_sel *sel)  in selector_read_index()  argument
845 	flags = ccu_lock(ccu);  in selector_read_index()
846 	reg_val = __ccu_read(ccu, sel->offset);  in selector_read_index()
847 	ccu_unlock(ccu, flags);  in selector_read_index()
855 			__func__, parent_sel, ccu->name, sel->offset);  in selector_read_index()
867 __sel_commit(struct ccu_data *ccu, struct bcm_clk_gate *gate,  in __sel_commit()  argument
885 		reg_val = __ccu_read(ccu, sel->offset);  in __sel_commit()
899 	enabled = __is_clk_gate_enabled(ccu, gate);  in __sel_commit()
900 	if (!enabled && !__clk_gate(ccu, gate, true))  in __sel_commit()
904 	reg_val = __ccu_read(ccu, sel->offset);  in __sel_commit()
906 	__ccu_write(ccu, sel->offset, reg_val);  in __sel_commit()
909 	if (!__clk_trigger(ccu, trig))  in __sel_commit()
913 	if (!enabled && !__clk_gate(ccu, gate, false))  in __sel_commit()
924 static bool sel_init(struct ccu_data *ccu, struct bcm_clk_gate *gate,  in sel_init()  argument
929 	return !__sel_commit(ccu, gate, sel, trig);  in sel_init()
937 static int selector_write(struct ccu_data *ccu, struct bcm_clk_gate *gate,  in selector_write()  argument
951 	flags = ccu_lock(ccu);  in selector_write()
952 	__ccu_write_enable(ccu);  in selector_write()
954 	ret = __sel_commit(ccu, gate, sel, trig);  in selector_write()
956 	__ccu_write_disable(ccu);  in selector_write()
957 	ccu_unlock(ccu, flags);  in selector_write()
972 	return clk_gate(bcm_clk->ccu, bcm_clk->init_data.name, gate, true);  in kona_peri_clk_enable()
980 	(void)clk_gate(bcm_clk->ccu, bcm_clk->init_data.name, gate, false);  in kona_peri_clk_disable()
988 	return is_clk_gate_enabled(bcm_clk->ccu, gate) ? 1 : 0;  in kona_peri_clk_is_enabled()
997 	return clk_recalc_rate(bcm_clk->ccu, &data->div, &data->pre_div,  in kona_peri_clk_recalc_rate()
1011 	return round_rate(bcm_clk->ccu, div, &bcm_clk->u.peri->pre_div,  in kona_peri_clk_round_rate()
1097 	ret = selector_write(bcm_clk->ccu, &data->gate, sel, trig, index);  in kona_peri_clk_set_parent()
1117 	index = selector_read_index(bcm_clk->ccu, &data->sel);  in kona_peri_clk_get_parent()
1154 	(void)round_rate(bcm_clk->ccu, div, &data->pre_div,  in kona_peri_clk_set_rate()
1161 	ret = divider_write(bcm_clk->ccu, &data->gate, &data->div,  in kona_peri_clk_set_rate()
1189 	struct ccu_data *ccu = bcm_clk->ccu;  in __peri_clk_init()  local
1196 	if (!policy_init(ccu, &peri->policy)) {  in __peri_clk_init()
1201 	if (!gate_init(ccu, &peri->gate)) {  in __peri_clk_init()
1205 	if (!hyst_init(ccu, &peri->hyst)) {  in __peri_clk_init()
1209 	if (!div_init(ccu, &peri->gate, &peri->div, &peri->trig)) {  in __peri_clk_init()
1222 	if (!div_init(ccu, &peri->gate, &peri->pre_div, trig)) {  in __peri_clk_init()
1228 	if (!sel_init(ccu, &peri->gate, &peri->sel, trig)) {  in __peri_clk_init()
1248 /* Set a CCU and all its clocks into their desired initial state */
1249 bool __init kona_ccu_init(struct ccu_data *ccu)  in kona_ccu_init()  argument
1253 	struct kona_clk *kona_clks = ccu->kona_clks;  in kona_ccu_init()
1256 	flags = ccu_lock(ccu);  in kona_ccu_init()
1257 	__ccu_write_enable(ccu);  in kona_ccu_init()
1259 	for (which = 0; which < ccu->clk_num; which++) {  in kona_ccu_init()
1262 		if (!bcm_clk->ccu)  in kona_ccu_init()
1268 	__ccu_write_disable(ccu);  in kona_ccu_init()
1269 	ccu_unlock(ccu, flags);  in kona_ccu_init()