1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	* Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
4	* Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
5	*
6	* Standard functionality for the common clock API. See Documentation/driver-api/clk.rst
7	*/
8
9	#include <linux/clk.h>
10	#include <linux/clk-provider.h>
11	#include <linux/clk/clk-conf.h>
12	#include <linux/module.h>
13	#include <linux/mutex.h>
14	#include <linux/spinlock.h>
15	#include <linux/err.h>
16	#include <linux/list.h>
17	#include <linux/slab.h>
18	#include <linux/of.h>
19	#include <linux/device.h>
20	#include <linux/init.h>
21	#include <linux/pm_runtime.h>
22	#include <linux/sched.h>
23	#include <linux/clkdev.h>
24
25	#include "clk.h"
26
27	static DEFINE_SPINLOCK(enable_lock);
28	static DEFINE_MUTEX(prepare_lock);
29
30	static struct task_struct *prepare_owner;
31	static struct task_struct *enable_owner;
32
33	static int prepare_refcnt;
34	static int enable_refcnt;
35
36	static HLIST_HEAD(clk_root_list);
37	static HLIST_HEAD(clk_orphan_list);
38	static LIST_HEAD(clk_notifier_list);
39
40	/* List of registered clks that use runtime PM */
41	static HLIST_HEAD(clk_rpm_list);
42	static DEFINE_MUTEX(clk_rpm_list_lock);
43
44	static const struct hlist_head *all_lists[] = {
45	&clk_root_list,
46	&clk_orphan_list,
47	NULL,
48	};
49
50	/*** private data structures ***/
51
52	struct clk_parent_map {
53	const struct clk_hw *hw;
54	struct clk_core *core;
55	const char *fw_name;
56	const char *name;
57	int index;
58	};
59
60	struct clk_core {
61	const char *name;
62	const struct clk_ops *ops;
63	struct clk_hw *hw;
64	struct module *owner;
65	struct device *dev;
66	struct hlist_node rpm_node;
67	struct device_node *of_node;
68	struct clk_core *parent;
69	struct clk_parent_map *parents;
70	u8 num_parents;
71	u8 new_parent_index;
72	unsigned long rate;
73	unsigned long req_rate;
74	unsigned long new_rate;
75	struct clk_core *new_parent;
76	struct clk_core *new_child;
77	unsigned long flags;
78	bool orphan;
79	bool rpm_enabled;
80	unsigned int enable_count;
81	unsigned int prepare_count;
82	unsigned int protect_count;
83	unsigned long min_rate;
84	unsigned long max_rate;
85	unsigned long accuracy;
86	int phase;
87	struct clk_duty duty;
88	struct hlist_head children;
89	struct hlist_node child_node;
90	struct hlist_head clks;
91	unsigned int notifier_count;
92	#ifdef CONFIG_DEBUG_FS
93	struct dentry *dentry;
94	struct hlist_node debug_node;
95	#endif
96	struct kref ref;
97	};
98
99	#define CREATE_TRACE_POINTS
100	#include <trace/events/clk.h>
101
102	struct clk {
103	struct clk_core *core;
104	struct device *dev;
105	const char *dev_id;
106	const char *con_id;
107	unsigned long min_rate;
108	unsigned long max_rate;
109	unsigned int exclusive_count;
110	struct hlist_node clks_node;
111	};
112
113	/*** runtime pm ***/
114	static int clk_pm_runtime_get(struct clk_core *core)
115	{
116	if (!core->rpm_enabled)
117	return 0;
118
119	return pm_runtime_resume_and_get(dev: core->dev);
120	}
121
122	static void clk_pm_runtime_put(struct clk_core *core)
123	{
124	if (!core->rpm_enabled)
125	return;
126
127	pm_runtime_put_sync(dev: core->dev);
128	}
129
130	/**
131	* clk_pm_runtime_get_all() - Runtime "get" all clk provider devices
132	*
133	* Call clk_pm_runtime_get() on all runtime PM enabled clks in the clk tree so
134	* that disabling unused clks avoids a deadlock where a device is runtime PM
135	* resuming/suspending and the runtime PM callback is trying to grab the
136	* prepare_lock for something like clk_prepare_enable() while
137	* clk_disable_unused_subtree() holds the prepare_lock and is trying to runtime
138	* PM resume/suspend the device as well.
139	*
140	* Context: Acquires the 'clk_rpm_list_lock' and returns with the lock held on
141	* success. Otherwise the lock is released on failure.
142	*
143	* Return: 0 on success, negative errno otherwise.
144	*/
145	static int clk_pm_runtime_get_all(void)
146	{
147	int ret;
148	struct clk_core *core, *failed;
149
150	/*
151	* Grab the list lock to prevent any new clks from being registered
152	* or unregistered until clk_pm_runtime_put_all().
153	*/
154	mutex_lock(&clk_rpm_list_lock);
155
156	/*
157	* Runtime PM "get" all the devices that are needed for the clks
158	* currently registered. Do this without holding the prepare_lock, to
159	* avoid the deadlock.
160	*/
161	hlist_for_each_entry(core, &clk_rpm_list, rpm_node) {
162	ret = clk_pm_runtime_get(core);
163	if (ret) {
164	failed = core;
165	pr_err("clk: Failed to runtime PM get '%s' for clk '%s'\n",
166	dev_name(failed->dev), failed->name);
167	goto err;
168	}
169	}
170
171	return 0;
172
173	err:
174	hlist_for_each_entry(core, &clk_rpm_list, rpm_node) {
175	if (core == failed)
176	break;
177
178	clk_pm_runtime_put(core);
179	}
180	mutex_unlock(lock: &clk_rpm_list_lock);
181
182	return ret;
183	}
184
185	/**
186	* clk_pm_runtime_put_all() - Runtime "put" all clk provider devices
187	*
188	* Put the runtime PM references taken in clk_pm_runtime_get_all() and release
189	* the 'clk_rpm_list_lock'.
190	*/
191	static void clk_pm_runtime_put_all(void)
192	{
193	struct clk_core *core;
194
195	hlist_for_each_entry(core, &clk_rpm_list, rpm_node)
196	clk_pm_runtime_put(core);
197	mutex_unlock(lock: &clk_rpm_list_lock);
198	}
199
200	static void clk_pm_runtime_init(struct clk_core *core)
201	{
202	struct device *dev = core->dev;
203
204	if (dev && pm_runtime_enabled(dev)) {
205	core->rpm_enabled = true;
206
207	mutex_lock(&clk_rpm_list_lock);
208	hlist_add_head(n: &core->rpm_node, h: &clk_rpm_list);
209	mutex_unlock(lock: &clk_rpm_list_lock);
210	}
211	}
212
213	/*** locking ***/
214	static void clk_prepare_lock(void)
215	{
216	if (!mutex_trylock(&prepare_lock)) {
217	if (prepare_owner == current) {
218	prepare_refcnt++;
219	return;
220	}
221	mutex_lock(&prepare_lock);
222	}
223	WARN_ON_ONCE(prepare_owner != NULL);
224	WARN_ON_ONCE(prepare_refcnt != 0);
225	prepare_owner = current;
226	prepare_refcnt = 1;
227	}
228
229	static void clk_prepare_unlock(void)
230	{
231	WARN_ON_ONCE(prepare_owner != current);
232	WARN_ON_ONCE(prepare_refcnt == 0);
233
234	if (--prepare_refcnt)
235	return;
236	prepare_owner = NULL;
237	mutex_unlock(lock: &prepare_lock);
238	}
239
240	static unsigned long clk_enable_lock(void)
241	__acquires(enable_lock)
242	{
243	unsigned long flags;
244
245	/*
246	* On UP systems, spin_trylock_irqsave() always returns true, even if
247	* we already hold the lock. So, in that case, we rely only on
248	* reference counting.
249	*/
250	if (!IS_ENABLED(CONFIG_SMP) ||
251	!spin_trylock_irqsave(&enable_lock, flags)) {
252	if (enable_owner == current) {
253	enable_refcnt++;
254	__acquire(enable_lock);
255	if (!IS_ENABLED(CONFIG_SMP))
256	local_save_flags(flags);
257	return flags;
258	}
259	spin_lock_irqsave(&enable_lock, flags);
260	}
261	WARN_ON_ONCE(enable_owner != NULL);
262	WARN_ON_ONCE(enable_refcnt != 0);
263	enable_owner = current;
264	enable_refcnt = 1;
265	return flags;
266	}
267
268	static void clk_enable_unlock(unsigned long flags)
269	__releases(enable_lock)
270	{
271	WARN_ON_ONCE(enable_owner != current);
272	WARN_ON_ONCE(enable_refcnt == 0);
273
274	if (--enable_refcnt) {
275	__release(enable_lock);
276	return;
277	}
278	enable_owner = NULL;
279	spin_unlock_irqrestore(lock: &enable_lock, flags);
280	}
281
282	static bool clk_core_rate_is_protected(struct clk_core *core)
283	{
284	return core->protect_count;
285	}
286
287	static bool clk_core_is_prepared(struct clk_core *core)
288	{
289	bool ret = false;
290
291	/*
292	* .is_prepared is optional for clocks that can prepare
293	* fall back to software usage counter if it is missing
294	*/
295	if (!core->ops->is_prepared)
296	return core->prepare_count;
297
298	if (!clk_pm_runtime_get(core)) {
299	ret = core->ops->is_prepared(core->hw);
300	clk_pm_runtime_put(core);
301	}
302
303	return ret;
304	}
305
306	static bool clk_core_is_enabled(struct clk_core *core)
307	{
308	bool ret = false;
309
310	/*
311	* .is_enabled is only mandatory for clocks that gate
312	* fall back to software usage counter if .is_enabled is missing
313	*/
314	if (!core->ops->is_enabled)
315	return core->enable_count;
316
317	/*
318	* Check if clock controller's device is runtime active before
319	* calling .is_enabled callback. If not, assume that clock is
320	* disabled, because we might be called from atomic context, from
321	* which pm_runtime_get() is not allowed.
322	* This function is called mainly from clk_disable_unused_subtree,
323	* which ensures proper runtime pm activation of controller before
324	* taking enable spinlock, but the below check is needed if one tries
325	* to call it from other places.
326	*/
327	if (core->rpm_enabled) {
328	pm_runtime_get_noresume(dev: core->dev);
329	if (!pm_runtime_active(dev: core->dev)) {
330	ret = false;
331	goto done;
332	}
333	}
334
335	/*
336	* This could be called with the enable lock held, or from atomic
337	* context. If the parent isn't enabled already, we can't do
338	* anything here. We can also assume this clock isn't enabled.
339	*/
340	if ((core->flags & CLK_OPS_PARENT_ENABLE) && core->parent)
341	if (!clk_core_is_enabled(core: core->parent)) {
342	ret = false;
343	goto done;
344	}
345
346	ret = core->ops->is_enabled(core->hw);
347	done:
348	if (core->rpm_enabled)
349	pm_runtime_put(dev: core->dev);
350
351	return ret;
352	}
353
354	/*** helper functions ***/
355
356	const char *__clk_get_name(const struct clk *clk)
357	{
358	return !clk ? NULL : clk->core->name;
359	}
360	EXPORT_SYMBOL_GPL(__clk_get_name);
361
362	const char *clk_hw_get_name(const struct clk_hw *hw)
363	{
364	return hw->core->name;
365	}
366	EXPORT_SYMBOL_GPL(clk_hw_get_name);
367
368	struct clk_hw *__clk_get_hw(struct clk *clk)
369	{
370	return !clk ? NULL : clk->core->hw;
371	}
372	EXPORT_SYMBOL_GPL(__clk_get_hw);
373
374	unsigned int clk_hw_get_num_parents(const struct clk_hw *hw)
375	{
376	return hw->core->num_parents;
377	}
378	EXPORT_SYMBOL_GPL(clk_hw_get_num_parents);
379
380	struct clk_hw *clk_hw_get_parent(const struct clk_hw *hw)
381	{
382	return hw->core->parent ? hw->core->parent->hw : NULL;
383	}
384	EXPORT_SYMBOL_GPL(clk_hw_get_parent);
385
386	static struct clk_core *__clk_lookup_subtree(const char *name,
387	struct clk_core *core)
388	{
389	struct clk_core *child;
390	struct clk_core *ret;
391
392	if (!strcmp(core->name, name))
393	return core;
394
395	hlist_for_each_entry(child, &core->children, child_node) {
396	ret = __clk_lookup_subtree(name, core: child);
397	if (ret)
398	return ret;
399	}
400
401	return NULL;
402	}
403
404	static struct clk_core *clk_core_lookup(const char *name)
405	{
406	struct clk_core *root_clk;
407	struct clk_core *ret;
408
409	if (!name)
410	return NULL;
411
412	/* search the 'proper' clk tree first */
413	hlist_for_each_entry(root_clk, &clk_root_list, child_node) {
414	ret = __clk_lookup_subtree(name, core: root_clk);
415	if (ret)
416	return ret;
417	}
418
419	/* if not found, then search the orphan tree */
420	hlist_for_each_entry(root_clk, &clk_orphan_list, child_node) {
421	ret = __clk_lookup_subtree(name, core: root_clk);
422	if (ret)
423	return ret;
424	}
425
426	return NULL;
427	}
428
429	#ifdef CONFIG_OF
430	static int of_parse_clkspec(const struct device_node *np, int index,
431	const char *name, struct of_phandle_args *out_args);
432	static struct clk_hw *
433	of_clk_get_hw_from_clkspec(struct of_phandle_args *clkspec);
434	#else
435	static inline int of_parse_clkspec(const struct device_node *np, int index,
436	const char *name,
437	struct of_phandle_args *out_args)
438	{
439	return -ENOENT;
440	}
441	static inline struct clk_hw *
442	of_clk_get_hw_from_clkspec(struct of_phandle_args *clkspec)
443	{
444	return ERR_PTR(-ENOENT);
445	}
446	#endif
447
448	/**
449	* clk_core_get - Find the clk_core parent of a clk
450	* @core: clk to find parent of
451	* @p_index: parent index to search for
452	*
453	* This is the preferred method for clk providers to find the parent of a
454	* clk when that parent is external to the clk controller. The parent_names
455	* array is indexed and treated as a local name matching a string in the device
456	* node's 'clock-names' property or as the 'con_id' matching the device's
457	* dev_name() in a clk_lookup. This allows clk providers to use their own
458	* namespace instead of looking for a globally unique parent string.
459	*
460	* For example the following DT snippet would allow a clock registered by the
461	* clock-controller@c001 that has a clk_init_data::parent_data array
462	* with 'xtal' in the 'name' member to find the clock provided by the
463	* clock-controller@f00abcd without needing to get the globally unique name of
464	* the xtal clk.
465	*
466	* parent: clock-controller@f00abcd {
467	* reg = <0xf00abcd 0xabcd>;
468	* #clock-cells = <0>;
469	* };
470	*
471	* clock-controller@c001 {
472	* reg = <0xc001 0xf00d>;
473	* clocks = <&parent>;
474	* clock-names = "xtal";
475	* #clock-cells = <1>;
476	* };
477	*
478	* Returns: -ENOENT when the provider can't be found or the clk doesn't
479	* exist in the provider or the name can't be found in the DT node or
480	* in a clkdev lookup. NULL when the provider knows about the clk but it
481	* isn't provided on this system.
482	* A valid clk_core pointer when the clk can be found in the provider.
483	*/
484	static struct clk_core *clk_core_get(struct clk_core *core, u8 p_index)
485	{
486	const char *name = core->parents[p_index].fw_name;
487	int index = core->parents[p_index].index;
488	struct clk_hw *hw = ERR_PTR(error: -ENOENT);
489	struct device *dev = core->dev;
490	const char *dev_id = dev ? dev_name(dev) : NULL;
491	struct device_node *np = core->of_node;
492	struct of_phandle_args clkspec;
493
494	if (np && (name || index >= 0) &&
495	!of_parse_clkspec(np, index, name, out_args: &clkspec)) {
496	hw = of_clk_get_hw_from_clkspec(clkspec: &clkspec);
497	of_node_put(node: clkspec.np);
498	} else if (name) {
499	/*
500	* If the DT search above couldn't find the provider fallback to
501	* looking up via clkdev based clk_lookups.
502	*/
503	hw = clk_find_hw(dev_id, con_id: name);
504	}
505
506	if (IS_ERR(ptr: hw))
507	return ERR_CAST(ptr: hw);
508
509	if (!hw)
510	return NULL;
511
512	return hw->core;
513	}
514
515	static void clk_core_fill_parent_index(struct clk_core *core, u8 index)
516	{
517	struct clk_parent_map *entry = &core->parents[index];
518	struct clk_core *parent;
519
520	if (entry->hw) {
521	parent = entry->hw->core;
522	} else {
523	parent = clk_core_get(core, p_index: index);
524	if (PTR_ERR(ptr: parent) == -ENOENT && entry->name)
525	parent = clk_core_lookup(name: entry->name);
526	}
527
528	/*
529	* We have a direct reference but it isn't registered yet?
530	* Orphan it and let clk_reparent() update the orphan status
531	* when the parent is registered.
532	*/
533	if (!parent)
534	parent = ERR_PTR(error: -EPROBE_DEFER);
535
536	/* Only cache it if it's not an error */
537	if (!IS_ERR(ptr: parent))
538	entry->core = parent;
539	}
540
541	static struct clk_core *clk_core_get_parent_by_index(struct clk_core *core,
542	u8 index)
543	{
544	if (!core || index >= core->num_parents || !core->parents)
545	return NULL;
546
547	if (!core->parents[index].core)
548	clk_core_fill_parent_index(core, index);
549
550	return core->parents[index].core;
551	}
552
553	struct clk_hw *
554	clk_hw_get_parent_by_index(const struct clk_hw *hw, unsigned int index)
555	{
556	struct clk_core *parent;
557
558	parent = clk_core_get_parent_by_index(core: hw->core, index);
559
560	return !parent ? NULL : parent->hw;
561	}
562	EXPORT_SYMBOL_GPL(clk_hw_get_parent_by_index);
563
564	unsigned int __clk_get_enable_count(struct clk *clk)
565	{
566	return !clk ? 0 : clk->core->enable_count;
567	}
568
569	static unsigned long clk_core_get_rate_nolock(struct clk_core *core)
570	{
571	if (!core)
572	return 0;
573
574	if (!core->num_parents || core->parent)
575	return core->rate;
576
577	/*
578	* Clk must have a parent because num_parents > 0 but the parent isn't
579	* known yet. Best to return 0 as the rate of this clk until we can
580	* properly recalc the rate based on the parent's rate.
581	*/
582	return 0;
583	}
584
585	unsigned long clk_hw_get_rate(const struct clk_hw *hw)
586	{
587	return clk_core_get_rate_nolock(core: hw->core);
588	}
589	EXPORT_SYMBOL_GPL(clk_hw_get_rate);
590
591	static unsigned long clk_core_get_accuracy_no_lock(struct clk_core *core)
592	{
593	if (!core)
594	return 0;
595
596	return core->accuracy;
597	}
598
599	unsigned long clk_hw_get_flags(const struct clk_hw *hw)
600	{
601	return hw->core->flags;
602	}
603	EXPORT_SYMBOL_GPL(clk_hw_get_flags);
604
605	bool clk_hw_is_prepared(const struct clk_hw *hw)
606	{
607	return clk_core_is_prepared(core: hw->core);
608	}
609	EXPORT_SYMBOL_GPL(clk_hw_is_prepared);
610
611	bool clk_hw_is_enabled(const struct clk_hw *hw)
612	{
613	return clk_core_is_enabled(core: hw->core);
614	}
615	EXPORT_SYMBOL_GPL(clk_hw_is_enabled);
616
617	bool __clk_is_enabled(struct clk *clk)
618	{
619	if (!clk)
620	return false;
621
622	return clk_core_is_enabled(core: clk->core);
623	}
624	EXPORT_SYMBOL_GPL(__clk_is_enabled);
625
626	static bool mux_is_better_rate(unsigned long rate, unsigned long now,
627	unsigned long best, unsigned long flags)
628	{
629	if (flags & CLK_MUX_ROUND_CLOSEST)
630	return abs(now - rate) < abs(best - rate);
631
632	return now <= rate && now > best;
633	}
634
635	static void clk_core_init_rate_req(struct clk_core * const core,
636	struct clk_rate_request *req,
637	unsigned long rate);
638
639	static int clk_core_round_rate_nolock(struct clk_core *core,
640	struct clk_rate_request *req);
641
642	static bool clk_core_has_parent(struct clk_core *core, const struct clk_core *parent)
643	{
644	struct clk_core *tmp;
645	unsigned int i;
646
647	/* Optimize for the case where the parent is already the parent. */
648	if (core->parent == parent)
649	return true;
650
651	for (i = 0; i < core->num_parents; i++) {
652	tmp = clk_core_get_parent_by_index(core, index: i);
653	if (!tmp)
654	continue;
655
656	if (tmp == parent)
657	return true;
658	}
659
660	return false;
661	}
662
663	static void
664	clk_core_forward_rate_req(struct clk_core *core,
665	const struct clk_rate_request *old_req,
666	struct clk_core *parent,
667	struct clk_rate_request *req,
668	unsigned long parent_rate)
669	{
670	if (WARN_ON(!clk_core_has_parent(core, parent)))
671	return;
672
673	clk_core_init_rate_req(core: parent, req, rate: parent_rate);
674
675	if (req->min_rate < old_req->min_rate)
676	req->min_rate = old_req->min_rate;
677
678	if (req->max_rate > old_req->max_rate)
679	req->max_rate = old_req->max_rate;
680	}
681
682	static int
683	clk_core_determine_rate_no_reparent(struct clk_hw *hw,
684	struct clk_rate_request *req)
685	{
686	struct clk_core *core = hw->core;
687	struct clk_core *parent = core->parent;
688	unsigned long best;
689	int ret;
690
691	if (core->flags & CLK_SET_RATE_PARENT) {
692	struct clk_rate_request parent_req;
693
694	if (!parent) {
695	req->rate = 0;
696	return 0;
697	}
698
699	clk_core_forward_rate_req(core, old_req: req, parent, req: &parent_req,
700	parent_rate: req->rate);
701
702	trace_clk_rate_request_start(req: &parent_req);
703
704	ret = clk_core_round_rate_nolock(core: parent, req: &parent_req);
705	if (ret)
706	return ret;
707
708	trace_clk_rate_request_done(req: &parent_req);
709
710	best = parent_req.rate;
711	} else if (parent) {
712	best = clk_core_get_rate_nolock(core: parent);
713	} else {
714	best = clk_core_get_rate_nolock(core);
715	}
716
717	req->best_parent_rate = best;
718	req->rate = best;
719
720	return 0;
721	}
722
723	int clk_mux_determine_rate_flags(struct clk_hw *hw,
724	struct clk_rate_request *req,
725	unsigned long flags)
726	{
727	struct clk_core *core = hw->core, *parent, *best_parent = NULL;
728	int i, num_parents, ret;
729	unsigned long best = 0;
730
731	/* if NO_REPARENT flag set, pass through to current parent */
732	if (core->flags & CLK_SET_RATE_NO_REPARENT)
733	return clk_core_determine_rate_no_reparent(hw, req);
734
735	/* find the parent that can provide the fastest rate <= rate */
736	num_parents = core->num_parents;
737	for (i = 0; i < num_parents; i++) {
738	unsigned long parent_rate;
739
740	parent = clk_core_get_parent_by_index(core, index: i);
741	if (!parent)
742	continue;
743
744	if (core->flags & CLK_SET_RATE_PARENT) {
745	struct clk_rate_request parent_req;
746
747	clk_core_forward_rate_req(core, old_req: req, parent, req: &parent_req, parent_rate: req->rate);
748
749	trace_clk_rate_request_start(req: &parent_req);
750
751	ret = clk_core_round_rate_nolock(core: parent, req: &parent_req);
752	if (ret)
753	continue;
754
755	trace_clk_rate_request_done(req: &parent_req);
756
757	parent_rate = parent_req.rate;
758	} else {
759	parent_rate = clk_core_get_rate_nolock(core: parent);
760	}
761
762	if (mux_is_better_rate(rate: req->rate, now: parent_rate,
763	best, flags)) {
764	best_parent = parent;
765	best = parent_rate;
766	}
767	}
768
769	if (!best_parent)
770	return -EINVAL;
771
772	req->best_parent_hw = best_parent->hw;
773	req->best_parent_rate = best;
774	req->rate = best;
775
776	return 0;
777	}
778	EXPORT_SYMBOL_GPL(clk_mux_determine_rate_flags);
779
780	struct clk *__clk_lookup(const char *name)
781	{
782	struct clk_core *core = clk_core_lookup(name);
783
784	return !core ? NULL : core->hw->clk;
785	}
786
787	static void clk_core_get_boundaries(struct clk_core *core,
788	unsigned long *min_rate,
789	unsigned long *max_rate)
790	{
791	struct clk *clk_user;
792
793	lockdep_assert_held(&prepare_lock);
794
795	*min_rate = core->min_rate;
796	*max_rate = core->max_rate;
797
798	hlist_for_each_entry(clk_user, &core->clks, clks_node)
799	*min_rate = max(*min_rate, clk_user->min_rate);
800
801	hlist_for_each_entry(clk_user, &core->clks, clks_node)
802	*max_rate = min(*max_rate, clk_user->max_rate);
803	}
804
805	/*
806	* clk_hw_get_rate_range() - returns the clock rate range for a hw clk
807	* @hw: the hw clk we want to get the range from
808	* @min_rate: pointer to the variable that will hold the minimum
809	* @max_rate: pointer to the variable that will hold the maximum
810	*
811	* Fills the @min_rate and @max_rate variables with the minimum and
812	* maximum that clock can reach.
813	*/
814	void clk_hw_get_rate_range(struct clk_hw *hw, unsigned long *min_rate,
815	unsigned long *max_rate)
816	{
817	clk_core_get_boundaries(core: hw->core, min_rate, max_rate);
818	}
819	EXPORT_SYMBOL_GPL(clk_hw_get_rate_range);
820
821	static bool clk_core_check_boundaries(struct clk_core *core,
822	unsigned long min_rate,
823	unsigned long max_rate)
824	{
825	struct clk *user;
826
827	lockdep_assert_held(&prepare_lock);
828
829	if (min_rate > core->max_rate || max_rate < core->min_rate)
830	return false;
831
832	hlist_for_each_entry(user, &core->clks, clks_node)
833	if (min_rate > user->max_rate || max_rate < user->min_rate)
834	return false;
835
836	return true;
837	}
838
839	void clk_hw_set_rate_range(struct clk_hw *hw, unsigned long min_rate,
840	unsigned long max_rate)
841	{
842	hw->core->min_rate = min_rate;
843	hw->core->max_rate = max_rate;
844	}
845	EXPORT_SYMBOL_GPL(clk_hw_set_rate_range);
846
847	/*
848	* __clk_mux_determine_rate - clk_ops::determine_rate implementation for a mux type clk
849	* @hw: mux type clk to determine rate on
850	* @req: rate request, also used to return preferred parent and frequencies
851	*
852	* Helper for finding best parent to provide a given frequency. This can be used
853	* directly as a determine_rate callback (e.g. for a mux), or from a more
854	* complex clock that may combine a mux with other operations.
855	*
856	* Returns: 0 on success, -EERROR value on error
857	*/
858	int __clk_mux_determine_rate(struct clk_hw *hw,
859	struct clk_rate_request *req)
860	{
861	return clk_mux_determine_rate_flags(hw, req, 0);
862	}
863	EXPORT_SYMBOL_GPL(__clk_mux_determine_rate);
864
865	int __clk_mux_determine_rate_closest(struct clk_hw *hw,
866	struct clk_rate_request *req)
867	{
868	return clk_mux_determine_rate_flags(hw, req, CLK_MUX_ROUND_CLOSEST);
869	}
870	EXPORT_SYMBOL_GPL(__clk_mux_determine_rate_closest);
871
872	/*
873	* clk_hw_determine_rate_no_reparent - clk_ops::determine_rate implementation for a clk that doesn't reparent
874	* @hw: mux type clk to determine rate on
875	* @req: rate request, also used to return preferred frequency
876	*
877	* Helper for finding best parent rate to provide a given frequency.
878	* This can be used directly as a determine_rate callback (e.g. for a
879	* mux), or from a more complex clock that may combine a mux with other
880	* operations.
881	*
882	* Returns: 0 on success, -EERROR value on error
883	*/
884	int clk_hw_determine_rate_no_reparent(struct clk_hw *hw,
885	struct clk_rate_request *req)
886	{
887	return clk_core_determine_rate_no_reparent(hw, req);
888	}
889	EXPORT_SYMBOL_GPL(clk_hw_determine_rate_no_reparent);
890
891	/*** clk api ***/
892
893	static void clk_core_rate_unprotect(struct clk_core *core)
894	{
895	lockdep_assert_held(&prepare_lock);
896
897	if (!core)
898	return;
899
900	if (WARN(core->protect_count == 0,
901	"%s already unprotected\n", core->name))
902	return;
903
904	if (--core->protect_count > 0)
905	return;
906
907	clk_core_rate_unprotect(core: core->parent);
908	}
909
910	static int clk_core_rate_nuke_protect(struct clk_core *core)
911	{
912	int ret;
913
914	lockdep_assert_held(&prepare_lock);
915
916	if (!core)
917	return -EINVAL;
918
919	if (core->protect_count == 0)
920	return 0;
921
922	ret = core->protect_count;
923	core->protect_count = 1;
924	clk_core_rate_unprotect(core);
925
926	return ret;
927	}
928
929	/**
930	* clk_rate_exclusive_put - release exclusivity over clock rate control
931	* @clk: the clk over which the exclusivity is released
932	*
933	* clk_rate_exclusive_put() completes a critical section during which a clock
934	* consumer cannot tolerate any other consumer making any operation on the
935	* clock which could result in a rate change or rate glitch. Exclusive clocks
936	* cannot have their rate changed, either directly or indirectly due to changes
937	* further up the parent chain of clocks. As a result, clocks up parent chain
938	* also get under exclusive control of the calling consumer.
939	*
940	* If exlusivity is claimed more than once on clock, even by the same consumer,
941	* the rate effectively gets locked as exclusivity can't be preempted.
942	*
943	* Calls to clk_rate_exclusive_put() must be balanced with calls to
944	* clk_rate_exclusive_get(). Calls to this function may sleep, and do not return
945	* error status.
946	*/
947	void clk_rate_exclusive_put(struct clk *clk)
948	{
949	if (!clk)
950	return;
951
952	clk_prepare_lock();
953
954	/*
955	* if there is something wrong with this consumer protect count, stop
956	* here before messing with the provider
957	*/
958	if (WARN_ON(clk->exclusive_count <= 0))
959	goto out;
960
961	clk_core_rate_unprotect(core: clk->core);
962	clk->exclusive_count--;
963	out:
964	clk_prepare_unlock();
965	}
966	EXPORT_SYMBOL_GPL(clk_rate_exclusive_put);
967
968	static void clk_core_rate_protect(struct clk_core *core)
969	{
970	lockdep_assert_held(&prepare_lock);
971
972	if (!core)
973	return;
974
975	if (core->protect_count == 0)
976	clk_core_rate_protect(core: core->parent);
977
978	core->protect_count++;
979	}
980
981	static void clk_core_rate_restore_protect(struct clk_core *core, int count)
982	{
983	lockdep_assert_held(&prepare_lock);
984
985	if (!core)
986	return;
987
988	if (count == 0)
989	return;
990
991	clk_core_rate_protect(core);
992	core->protect_count = count;
993	}
994
995	/**
996	* clk_rate_exclusive_get - get exclusivity over the clk rate control
997	* @clk: the clk over which the exclusity of rate control is requested
998	*
999	* clk_rate_exclusive_get() begins a critical section during which a clock
1000	* consumer cannot tolerate any other consumer making any operation on the
1001	* clock which could result in a rate change or rate glitch. Exclusive clocks
1002	* cannot have their rate changed, either directly or indirectly due to changes
1003	* further up the parent chain of clocks. As a result, clocks up parent chain
1004	* also get under exclusive control of the calling consumer.
1005	*
1006	* If exlusivity is claimed more than once on clock, even by the same consumer,
1007	* the rate effectively gets locked as exclusivity can't be preempted.
1008	*
1009	* Calls to clk_rate_exclusive_get() should be balanced with calls to
1010	* clk_rate_exclusive_put(). Calls to this function may sleep.
1011	* Returns 0 on success, -EERROR otherwise
1012	*/
1013	int clk_rate_exclusive_get(struct clk *clk)
1014	{
1015	if (!clk)
1016	return 0;
1017
1018	clk_prepare_lock();
1019	clk_core_rate_protect(core: clk->core);
1020	clk->exclusive_count++;
1021	clk_prepare_unlock();
1022
1023	return 0;
1024	}
1025	EXPORT_SYMBOL_GPL(clk_rate_exclusive_get);
1026
1027	static void devm_clk_rate_exclusive_put(void *data)
1028	{
1029	struct clk *clk = data;
1030
1031	clk_rate_exclusive_put(clk);
1032	}
1033
1034	int devm_clk_rate_exclusive_get(struct device *dev, struct clk *clk)
1035	{
1036	int ret;
1037
1038	ret = clk_rate_exclusive_get(clk);
1039	if (ret)
1040	return ret;
1041
1042	return devm_add_action_or_reset(dev, devm_clk_rate_exclusive_put, clk);
1043	}
1044	EXPORT_SYMBOL_GPL(devm_clk_rate_exclusive_get);
1045
1046	static void clk_core_unprepare(struct clk_core *core)
1047	{
1048	lockdep_assert_held(&prepare_lock);
1049
1050	if (!core)
1051	return;
1052
1053	if (WARN(core->prepare_count == 0,
1054	"%s already unprepared\n", core->name))
1055	return;
1056
1057	if (WARN(core->prepare_count == 1 && core->flags & CLK_IS_CRITICAL,
1058	"Unpreparing critical %s\n", core->name))
1059	return;
1060
1061	if (core->flags & CLK_SET_RATE_GATE)
1062	clk_core_rate_unprotect(core);
1063
1064	if (--core->prepare_count > 0)
1065	return;
1066
1067	WARN(core->enable_count > 0, "Unpreparing enabled %s\n", core->name);
1068
1069	trace_clk_unprepare(core);
1070
1071	if (core->ops->unprepare)
1072	core->ops->unprepare(core->hw);
1073
1074	trace_clk_unprepare_complete(core);
1075	clk_core_unprepare(core: core->parent);
1076	clk_pm_runtime_put(core);
1077	}
1078
1079	static void clk_core_unprepare_lock(struct clk_core *core)
1080	{
1081	clk_prepare_lock();
1082	clk_core_unprepare(core);
1083	clk_prepare_unlock();
1084	}
1085
1086	/**
1087	* clk_unprepare - undo preparation of a clock source
1088	* @clk: the clk being unprepared
1089	*
1090	* clk_unprepare may sleep, which differentiates it from clk_disable. In a
1091	* simple case, clk_unprepare can be used instead of clk_disable to gate a clk
1092	* if the operation may sleep. One example is a clk which is accessed over
1093	* I2c. In the complex case a clk gate operation may require a fast and a slow
1094	* part. It is this reason that clk_unprepare and clk_disable are not mutually
1095	* exclusive. In fact clk_disable must be called before clk_unprepare.
1096	*/
1097	void clk_unprepare(struct clk *clk)
1098	{
1099	if (IS_ERR_OR_NULL(ptr: clk))
1100	return;
1101
1102	clk_core_unprepare_lock(core: clk->core);
1103	}
1104	EXPORT_SYMBOL_GPL(clk_unprepare);
1105
1106	static int clk_core_prepare(struct clk_core *core)
1107	{
1108	int ret = 0;
1109
1110	lockdep_assert_held(&prepare_lock);
1111
1112	if (!core)
1113	return 0;
1114
1115	if (core->prepare_count == 0) {
1116	ret = clk_pm_runtime_get(core);
1117	if (ret)
1118	return ret;
1119
1120	ret = clk_core_prepare(core: core->parent);
1121	if (ret)
1122	goto runtime_put;
1123
1124	trace_clk_prepare(core);
1125
1126	if (core->ops->prepare)
1127	ret = core->ops->prepare(core->hw);
1128
1129	trace_clk_prepare_complete(core);
1130
1131	if (ret)
1132	goto unprepare;
1133	}
1134
1135	core->prepare_count++;
1136
1137	/*
1138	* CLK_SET_RATE_GATE is a special case of clock protection
1139	* Instead of a consumer claiming exclusive rate control, it is
1140	* actually the provider which prevents any consumer from making any
1141	* operation which could result in a rate change or rate glitch while
1142	* the clock is prepared.
1143	*/
1144	if (core->flags & CLK_SET_RATE_GATE)
1145	clk_core_rate_protect(core);
1146
1147	return 0;
1148	unprepare:
1149	clk_core_unprepare(core: core->parent);
1150	runtime_put:
1151	clk_pm_runtime_put(core);
1152	return ret;
1153	}
1154
1155	static int clk_core_prepare_lock(struct clk_core *core)
1156	{
1157	int ret;
1158
1159	clk_prepare_lock();
1160	ret = clk_core_prepare(core);
1161	clk_prepare_unlock();
1162
1163	return ret;
1164	}
1165
1166	/**
1167	* clk_prepare - prepare a clock source
1168	* @clk: the clk being prepared
1169	*
1170	* clk_prepare may sleep, which differentiates it from clk_enable. In a simple
1171	* case, clk_prepare can be used instead of clk_enable to ungate a clk if the
1172	* operation may sleep. One example is a clk which is accessed over I2c. In
1173	* the complex case a clk ungate operation may require a fast and a slow part.
1174	* It is this reason that clk_prepare and clk_enable are not mutually
1175	* exclusive. In fact clk_prepare must be called before clk_enable.
1176	* Returns 0 on success, -EERROR otherwise.
1177	*/
1178	int clk_prepare(struct clk *clk)
1179	{
1180	if (!clk)
1181	return 0;
1182
1183	return clk_core_prepare_lock(core: clk->core);
1184	}
1185	EXPORT_SYMBOL_GPL(clk_prepare);
1186
1187	static void clk_core_disable(struct clk_core *core)
1188	{
1189	lockdep_assert_held(&enable_lock);
1190
1191	if (!core)
1192	return;
1193
1194	if (WARN(core->enable_count == 0, "%s already disabled\n", core->name))
1195	return;
1196
1197	if (WARN(core->enable_count == 1 && core->flags & CLK_IS_CRITICAL,
1198	"Disabling critical %s\n", core->name))
1199	return;
1200
1201	if (--core->enable_count > 0)
1202	return;
1203
1204	trace_clk_disable(core);
1205
1206	if (core->ops->disable)
1207	core->ops->disable(core->hw);
1208
1209	trace_clk_disable_complete(core);
1210
1211	clk_core_disable(core: core->parent);
1212	}
1213
1214	static void clk_core_disable_lock(struct clk_core *core)
1215	{
1216	unsigned long flags;
1217
1218	flags = clk_enable_lock();
1219	clk_core_disable(core);
1220	clk_enable_unlock(flags);
1221	}
1222
1223	/**
1224	* clk_disable - gate a clock
1225	* @clk: the clk being gated
1226	*
1227	* clk_disable must not sleep, which differentiates it from clk_unprepare. In
1228	* a simple case, clk_disable can be used instead of clk_unprepare to gate a
1229	* clk if the operation is fast and will never sleep. One example is a
1230	* SoC-internal clk which is controlled via simple register writes. In the
1231	* complex case a clk gate operation may require a fast and a slow part. It is
1232	* this reason that clk_unprepare and clk_disable are not mutually exclusive.
1233	* In fact clk_disable must be called before clk_unprepare.
1234	*/
1235	void clk_disable(struct clk *clk)
1236	{
1237	if (IS_ERR_OR_NULL(ptr: clk))
1238	return;
1239
1240	clk_core_disable_lock(core: clk->core);
1241	}
1242	EXPORT_SYMBOL_GPL(clk_disable);
1243
1244	static int clk_core_enable(struct clk_core *core)
1245	{
1246	int ret = 0;
1247
1248	lockdep_assert_held(&enable_lock);
1249
1250	if (!core)
1251	return 0;
1252
1253	if (WARN(core->prepare_count == 0,
1254	"Enabling unprepared %s\n", core->name))
1255	return -ESHUTDOWN;
1256
1257	if (core->enable_count == 0) {
1258	ret = clk_core_enable(core: core->parent);
1259
1260	if (ret)
1261	return ret;
1262
1263	trace_clk_enable(core);
1264
1265	if (core->ops->enable)
1266	ret = core->ops->enable(core->hw);
1267
1268	trace_clk_enable_complete(core);
1269
1270	if (ret) {
1271	clk_core_disable(core: core->parent);
1272	return ret;
1273	}
1274	}
1275
1276	core->enable_count++;
1277	return 0;
1278	}
1279
1280	static int clk_core_enable_lock(struct clk_core *core)
1281	{
1282	unsigned long flags;
1283	int ret;
1284
1285	flags = clk_enable_lock();
1286	ret = clk_core_enable(core);
1287	clk_enable_unlock(flags);
1288
1289	return ret;
1290	}
1291
1292	/**
1293	* clk_gate_restore_context - restore context for poweroff
1294	* @hw: the clk_hw pointer of clock whose state is to be restored
1295	*
1296	* The clock gate restore context function enables or disables
1297	* the gate clocks based on the enable_count. This is done in cases
1298	* where the clock context is lost and based on the enable_count
1299	* the clock either needs to be enabled/disabled. This
1300	* helps restore the state of gate clocks.
1301	*/
1302	void clk_gate_restore_context(struct clk_hw *hw)
1303	{
1304	struct clk_core *core = hw->core;
1305
1306	if (core->enable_count)
1307	core->ops->enable(hw);
1308	else
1309	core->ops->disable(hw);
1310	}
1311	EXPORT_SYMBOL_GPL(clk_gate_restore_context);
1312
1313	static int clk_core_save_context(struct clk_core *core)
1314	{
1315	struct clk_core *child;
1316	int ret = 0;
1317
1318	hlist_for_each_entry(child, &core->children, child_node) {
1319	ret = clk_core_save_context(core: child);
1320	if (ret < 0)
1321	return ret;
1322	}
1323
1324	if (core->ops && core->ops->save_context)
1325	ret = core->ops->save_context(core->hw);
1326
1327	return ret;
1328	}
1329
1330	static void clk_core_restore_context(struct clk_core *core)
1331	{
1332	struct clk_core *child;
1333
1334	if (core->ops && core->ops->restore_context)
1335	core->ops->restore_context(core->hw);
1336
1337	hlist_for_each_entry(child, &core->children, child_node)
1338	clk_core_restore_context(core: child);
1339	}
1340
1341	/**
1342	* clk_save_context - save clock context for poweroff
1343	*
1344	* Saves the context of the clock register for powerstates in which the
1345	* contents of the registers will be lost. Occurs deep within the suspend
1346	* code. Returns 0 on success.
1347	*/
1348	int clk_save_context(void)
1349	{
1350	struct clk_core *clk;
1351	int ret;
1352
1353	hlist_for_each_entry(clk, &clk_root_list, child_node) {
1354	ret = clk_core_save_context(core: clk);
1355	if (ret < 0)
1356	return ret;
1357	}
1358
1359	hlist_for_each_entry(clk, &clk_orphan_list, child_node) {
1360	ret = clk_core_save_context(core: clk);
1361	if (ret < 0)
1362	return ret;
1363	}
1364
1365	return 0;
1366	}
1367	EXPORT_SYMBOL_GPL(clk_save_context);
1368
1369	/**
1370	* clk_restore_context - restore clock context after poweroff
1371	*
1372	* Restore the saved clock context upon resume.
1373	*
1374	*/
1375	void clk_restore_context(void)
1376	{
1377	struct clk_core *core;
1378
1379	hlist_for_each_entry(core, &clk_root_list, child_node)
1380	clk_core_restore_context(core);
1381
1382	hlist_for_each_entry(core, &clk_orphan_list, child_node)
1383	clk_core_restore_context(core);
1384	}
1385	EXPORT_SYMBOL_GPL(clk_restore_context);
1386
1387	/**
1388	* clk_enable - ungate a clock
1389	* @clk: the clk being ungated
1390	*
1391	* clk_enable must not sleep, which differentiates it from clk_prepare. In a
1392	* simple case, clk_enable can be used instead of clk_prepare to ungate a clk
1393	* if the operation will never sleep. One example is a SoC-internal clk which
1394	* is controlled via simple register writes. In the complex case a clk ungate
1395	* operation may require a fast and a slow part. It is this reason that
1396	* clk_enable and clk_prepare are not mutually exclusive. In fact clk_prepare
1397	* must be called before clk_enable. Returns 0 on success, -EERROR
1398	* otherwise.
1399	*/
1400	int clk_enable(struct clk *clk)
1401	{
1402	if (!clk)
1403	return 0;
1404
1405	return clk_core_enable_lock(core: clk->core);
1406	}
1407	EXPORT_SYMBOL_GPL(clk_enable);
1408
1409	/**
1410	* clk_is_enabled_when_prepared - indicate if preparing a clock also enables it.
1411	* @clk: clock source
1412	*
1413	* Returns true if clk_prepare() implicitly enables the clock, effectively
1414	* making clk_enable()/clk_disable() no-ops, false otherwise.
1415	*
1416	* This is of interest mainly to power management code where actually
1417	* disabling the clock also requires unpreparing it to have any material
1418	* effect.
1419	*
1420	* Regardless of the value returned here, the caller must always invoke
1421	* clk_enable() or clk_prepare_enable() and counterparts for usage counts
1422	* to be right.
1423	*/
1424	bool clk_is_enabled_when_prepared(struct clk *clk)
1425	{
1426	return clk && !(clk->core->ops->enable && clk->core->ops->disable);
1427	}
1428	EXPORT_SYMBOL_GPL(clk_is_enabled_when_prepared);
1429
1430	static int clk_core_prepare_enable(struct clk_core *core)
1431	{
1432	int ret;
1433
1434	ret = clk_core_prepare_lock(core);
1435	if (ret)
1436	return ret;
1437
1438	ret = clk_core_enable_lock(core);
1439	if (ret)
1440	clk_core_unprepare_lock(core);
1441
1442	return ret;
1443	}
1444
1445	static void clk_core_disable_unprepare(struct clk_core *core)
1446	{
1447	clk_core_disable_lock(core);
1448	clk_core_unprepare_lock(core);
1449	}
1450
1451	static void __init clk_unprepare_unused_subtree(struct clk_core *core)
1452	{
1453	struct clk_core *child;
1454
1455	lockdep_assert_held(&prepare_lock);
1456
1457	hlist_for_each_entry(child, &core->children, child_node)
1458	clk_unprepare_unused_subtree(core: child);
1459
1460	if (core->prepare_count)
1461	return;
1462
1463	if (core->flags & CLK_IGNORE_UNUSED)
1464	return;
1465
1466	if (clk_core_is_prepared(core)) {
1467	trace_clk_unprepare(core);
1468	if (core->ops->unprepare_unused)
1469	core->ops->unprepare_unused(core->hw);
1470	else if (core->ops->unprepare)
1471	core->ops->unprepare(core->hw);
1472	trace_clk_unprepare_complete(core);
1473	}
1474	}
1475
1476	static void __init clk_disable_unused_subtree(struct clk_core *core)
1477	{
1478	struct clk_core *child;
1479	unsigned long flags;
1480
1481	lockdep_assert_held(&prepare_lock);
1482
1483	hlist_for_each_entry(child, &core->children, child_node)
1484	clk_disable_unused_subtree(core: child);
1485
1486	if (core->flags & CLK_OPS_PARENT_ENABLE)
1487	clk_core_prepare_enable(core: core->parent);
1488
1489	flags = clk_enable_lock();
1490
1491	if (core->enable_count)
1492	goto unlock_out;
1493
1494	if (core->flags & CLK_IGNORE_UNUSED)
1495	goto unlock_out;
1496
1497	/*
1498	* some gate clocks have special needs during the disable-unused
1499	* sequence. call .disable_unused if available, otherwise fall
1500	* back to .disable
1501	*/
1502	if (clk_core_is_enabled(core)) {
1503	trace_clk_disable(core);
1504	if (core->ops->disable_unused)
1505	core->ops->disable_unused(core->hw);
1506	else if (core->ops->disable)
1507	core->ops->disable(core->hw);
1508	trace_clk_disable_complete(core);
1509	}
1510
1511	unlock_out:
1512	clk_enable_unlock(flags);
1513	if (core->flags & CLK_OPS_PARENT_ENABLE)
1514	clk_core_disable_unprepare(core: core->parent);
1515	}
1516
1517	static bool clk_ignore_unused __initdata;
1518	static int __init clk_ignore_unused_setup(char *__unused)
1519	{
1520	clk_ignore_unused = true;
1521	return 1;
1522	}
1523	__setup("clk_ignore_unused", clk_ignore_unused_setup);
1524
1525	static int __init clk_disable_unused(void)
1526	{
1527	struct clk_core *core;
1528	int ret;
1529
1530	if (clk_ignore_unused) {
1531	pr_warn("clk: Not disabling unused clocks\n");
1532	return 0;
1533	}
1534
1535	pr_info("clk: Disabling unused clocks\n");
1536
1537	ret = clk_pm_runtime_get_all();
1538	if (ret)
1539	return ret;
1540	/*
1541	* Grab the prepare lock to keep the clk topology stable while iterating
1542	* over clks.
1543	*/
1544	clk_prepare_lock();
1545
1546	hlist_for_each_entry(core, &clk_root_list, child_node)
1547	clk_disable_unused_subtree(core);
1548
1549	hlist_for_each_entry(core, &clk_orphan_list, child_node)
1550	clk_disable_unused_subtree(core);
1551
1552	hlist_for_each_entry(core, &clk_root_list, child_node)
1553	clk_unprepare_unused_subtree(core);
1554
1555	hlist_for_each_entry(core, &clk_orphan_list, child_node)
1556	clk_unprepare_unused_subtree(core);
1557
1558	clk_prepare_unlock();
1559
1560	clk_pm_runtime_put_all();
1561
1562	return 0;
1563	}
1564	late_initcall_sync(clk_disable_unused);
1565
1566	static int clk_core_determine_round_nolock(struct clk_core *core,
1567	struct clk_rate_request *req)
1568	{
1569	long rate;
1570
1571	lockdep_assert_held(&prepare_lock);
1572
1573	if (!core)
1574	return 0;
1575
1576	/*
1577	* Some clock providers hand-craft their clk_rate_requests and
1578	* might not fill min_rate and max_rate.
1579	*
1580	* If it's the case, clamping the rate is equivalent to setting
1581	* the rate to 0 which is bad. Skip the clamping but complain so
1582	* that it gets fixed, hopefully.
1583	*/
1584	if (!req->min_rate && !req->max_rate)
1585	pr_warn("%s: %s: clk_rate_request has initialized min or max rate.\n",
1586	__func__, core->name);
1587	else
1588	req->rate = clamp(req->rate, req->min_rate, req->max_rate);
1589
1590	/*
1591	* At this point, core protection will be disabled
1592	* - if the provider is not protected at all
1593	* - if the calling consumer is the only one which has exclusivity
1594	* over the provider
1595	*/
1596	if (clk_core_rate_is_protected(core)) {
1597	req->rate = core->rate;
1598	} else if (core->ops->determine_rate) {
1599	return core->ops->determine_rate(core->hw, req);
1600	} else if (core->ops->round_rate) {
1601	rate = core->ops->round_rate(core->hw, req->rate,
1602	&req->best_parent_rate);
1603	if (rate < 0)
1604	return rate;
1605
1606	req->rate = rate;
1607	} else {
1608	return -EINVAL;
1609	}
1610
1611	return 0;
1612	}
1613
1614	static void clk_core_init_rate_req(struct clk_core * const core,
1615	struct clk_rate_request *req,
1616	unsigned long rate)
1617	{
1618	struct clk_core *parent;
1619
1620	if (WARN_ON(!req))
1621	return;
1622
1623	memset(req, 0, sizeof(*req));
1624	req->max_rate = ULONG_MAX;
1625
1626	if (!core)
1627	return;
1628
1629	req->core = core;
1630	req->rate = rate;
1631	clk_core_get_boundaries(core, min_rate: &req->min_rate, max_rate: &req->max_rate);
1632
1633	parent = core->parent;
1634	if (parent) {
1635	req->best_parent_hw = parent->hw;
1636	req->best_parent_rate = parent->rate;
1637	} else {
1638	req->best_parent_hw = NULL;
1639	req->best_parent_rate = 0;
1640	}
1641	}
1642
1643	/**
1644	* clk_hw_init_rate_request - Initializes a clk_rate_request
1645	* @hw: the clk for which we want to submit a rate request
1646	* @req: the clk_rate_request structure we want to initialise
1647	* @rate: the rate which is to be requested
1648	*
1649	* Initializes a clk_rate_request structure to submit to
1650	* __clk_determine_rate() or similar functions.
1651	*/
1652	void clk_hw_init_rate_request(const struct clk_hw *hw,
1653	struct clk_rate_request *req,
1654	unsigned long rate)
1655	{
1656	if (WARN_ON(!hw || !req))
1657	return;
1658
1659	clk_core_init_rate_req(core: hw->core, req, rate);
1660	}
1661	EXPORT_SYMBOL_GPL(clk_hw_init_rate_request);
1662
1663	/**
1664	* clk_hw_forward_rate_request - Forwards a clk_rate_request to a clock's parent
1665	* @hw: the original clock that got the rate request
1666	* @old_req: the original clk_rate_request structure we want to forward
1667	* @parent: the clk we want to forward @old_req to
1668	* @req: the clk_rate_request structure we want to initialise
1669	* @parent_rate: The rate which is to be requested to @parent
1670	*
1671	* Initializes a clk_rate_request structure to submit to a clock parent
1672	* in __clk_determine_rate() or similar functions.
1673	*/
1674	void clk_hw_forward_rate_request(const struct clk_hw *hw,
1675	const struct clk_rate_request *old_req,
1676	const struct clk_hw *parent,
1677	struct clk_rate_request *req,
1678	unsigned long parent_rate)
1679	{
1680	if (WARN_ON(!hw || !old_req || !parent || !req))
1681	return;
1682
1683	clk_core_forward_rate_req(core: hw->core, old_req,
1684	parent: parent->core, req,
1685	parent_rate);
1686	}
1687	EXPORT_SYMBOL_GPL(clk_hw_forward_rate_request);
1688
1689	static bool clk_core_can_round(struct clk_core * const core)
1690	{
1691	return core->ops->determine_rate || core->ops->round_rate;
1692	}
1693
1694	static int clk_core_round_rate_nolock(struct clk_core *core,
1695	struct clk_rate_request *req)
1696	{
1697	int ret;
1698
1699	lockdep_assert_held(&prepare_lock);
1700
1701	if (!core) {
1702	req->rate = 0;
1703	return 0;
1704	}
1705
1706	if (clk_core_can_round(core))
1707	return clk_core_determine_round_nolock(core, req);
1708
1709	if (core->flags & CLK_SET_RATE_PARENT) {
1710	struct clk_rate_request parent_req;
1711
1712	clk_core_forward_rate_req(core, old_req: req, parent: core->parent, req: &parent_req, parent_rate: req->rate);
1713
1714	trace_clk_rate_request_start(req: &parent_req);
1715
1716	ret = clk_core_round_rate_nolock(core: core->parent, req: &parent_req);
1717	if (ret)
1718	return ret;
1719
1720	trace_clk_rate_request_done(req: &parent_req);
1721
1722	req->best_parent_rate = parent_req.rate;
1723	req->rate = parent_req.rate;
1724
1725	return 0;
1726	}
1727
1728	req->rate = core->rate;
1729	return 0;
1730	}
1731
1732	/**
1733	* __clk_determine_rate - get the closest rate actually supported by a clock
1734	* @hw: determine the rate of this clock
1735	* @req: target rate request
1736	*
1737	* Useful for clk_ops such as .set_rate and .determine_rate.
1738	*/
1739	int __clk_determine_rate(struct clk_hw *hw, struct clk_rate_request *req)
1740	{
1741	if (!hw) {
1742	req->rate = 0;
1743	return 0;
1744	}
1745
1746	return clk_core_round_rate_nolock(core: hw->core, req);
1747	}
1748	EXPORT_SYMBOL_GPL(__clk_determine_rate);
1749
1750	/**
1751	* clk_hw_round_rate() - round the given rate for a hw clk
1752	* @hw: the hw clk for which we are rounding a rate
1753	* @rate: the rate which is to be rounded
1754	*
1755	* Takes in a rate as input and rounds it to a rate that the clk can actually
1756	* use.
1757	*
1758	* Context: prepare_lock must be held.
1759	* For clk providers to call from within clk_ops such as .round_rate,
1760	* .determine_rate.
1761	*
1762	* Return: returns rounded rate of hw clk if clk supports round_rate operation
1763	* else returns the parent rate.
1764	*/
1765	unsigned long clk_hw_round_rate(struct clk_hw *hw, unsigned long rate)
1766	{
1767	int ret;
1768	struct clk_rate_request req;
1769
1770	clk_core_init_rate_req(core: hw->core, req: &req, rate);
1771
1772	trace_clk_rate_request_start(req: &req);
1773
1774	ret = clk_core_round_rate_nolock(core: hw->core, req: &req);
1775	if (ret)
1776	return 0;
1777
1778	trace_clk_rate_request_done(req: &req);
1779
1780	return req.rate;
1781	}
1782	EXPORT_SYMBOL_GPL(clk_hw_round_rate);
1783
1784	/**
1785	* clk_round_rate - round the given rate for a clk
1786	* @clk: the clk for which we are rounding a rate
1787	* @rate: the rate which is to be rounded
1788	*
1789	* Takes in a rate as input and rounds it to a rate that the clk can actually
1790	* use which is then returned. If clk doesn't support round_rate operation
1791	* then the parent rate is returned.
1792	*/
1793	long clk_round_rate(struct clk *clk, unsigned long rate)
1794	{
1795	struct clk_rate_request req;
1796	int ret;
1797
1798	if (!clk)
1799	return 0;
1800
1801	clk_prepare_lock();
1802
1803	if (clk->exclusive_count)
1804	clk_core_rate_unprotect(core: clk->core);
1805
1806	clk_core_init_rate_req(core: clk->core, req: &req, rate);
1807
1808	trace_clk_rate_request_start(req: &req);
1809
1810	ret = clk_core_round_rate_nolock(core: clk->core, req: &req);
1811
1812	trace_clk_rate_request_done(req: &req);
1813
1814	if (clk->exclusive_count)
1815	clk_core_rate_protect(core: clk->core);
1816
1817	clk_prepare_unlock();
1818
1819	if (ret)
1820	return ret;
1821
1822	return req.rate;
1823	}
1824	EXPORT_SYMBOL_GPL(clk_round_rate);
1825
1826	/**
1827	* __clk_notify - call clk notifier chain
1828	* @core: clk that is changing rate
1829	* @msg: clk notifier type (see include/linux/clk.h)
1830	* @old_rate: old clk rate
1831	* @new_rate: new clk rate
1832	*
1833	* Triggers a notifier call chain on the clk rate-change notification
1834	* for 'clk'. Passes a pointer to the struct clk and the previous
1835	* and current rates to the notifier callback. Intended to be called by
1836	* internal clock code only. Returns NOTIFY_DONE from the last driver
1837	* called if all went well, or NOTIFY_STOP or NOTIFY_BAD immediately if
1838	* a driver returns that.
1839	*/
1840	static int __clk_notify(struct clk_core *core, unsigned long msg,
1841	unsigned long old_rate, unsigned long new_rate)
1842	{
1843	struct clk_notifier *cn;
1844	struct clk_notifier_data cnd;
1845	int ret = NOTIFY_DONE;
1846
1847	cnd.old_rate = old_rate;
1848	cnd.new_rate = new_rate;
1849
1850	list_for_each_entry(cn, &clk_notifier_list, node) {
1851	if (cn->clk->core == core) {
1852	cnd.clk = cn->clk;
1853	ret = srcu_notifier_call_chain(nh: &cn->notifier_head, val: msg,
1854	v: &cnd);
1855	if (ret & NOTIFY_STOP_MASK)
1856	return ret;
1857	}
1858	}
1859
1860	return ret;
1861	}
1862
1863	/**
1864	* __clk_recalc_accuracies
1865	* @core: first clk in the subtree
1866	*
1867	* Walks the subtree of clks starting with clk and recalculates accuracies as
1868	* it goes. Note that if a clk does not implement the .recalc_accuracy
1869	* callback then it is assumed that the clock will take on the accuracy of its
1870	* parent.
1871	*/
1872	static void __clk_recalc_accuracies(struct clk_core *core)
1873	{
1874	unsigned long parent_accuracy = 0;
1875	struct clk_core *child;
1876
1877	lockdep_assert_held(&prepare_lock);
1878
1879	if (core->parent)
1880	parent_accuracy = core->parent->accuracy;
1881
1882	if (core->ops->recalc_accuracy)
1883	core->accuracy = core->ops->recalc_accuracy(core->hw,
1884	parent_accuracy);
1885	else
1886	core->accuracy = parent_accuracy;
1887
1888	hlist_for_each_entry(child, &core->children, child_node)
1889	__clk_recalc_accuracies(core: child);
1890	}
1891
1892	static long clk_core_get_accuracy_recalc(struct clk_core *core)
1893	{
1894	if (core && (core->flags & CLK_GET_ACCURACY_NOCACHE))
1895	__clk_recalc_accuracies(core);
1896
1897	return clk_core_get_accuracy_no_lock(core);
1898	}
1899
1900	/**
1901	* clk_get_accuracy - return the accuracy of clk
1902	* @clk: the clk whose accuracy is being returned
1903	*
1904	* Simply returns the cached accuracy of the clk, unless
1905	* CLK_GET_ACCURACY_NOCACHE flag is set, which means a recalc_rate will be
1906	* issued.
1907	* If clk is NULL then returns 0.
1908	*/
1909	long clk_get_accuracy(struct clk *clk)
1910	{
1911	long accuracy;
1912
1913	if (!clk)
1914	return 0;
1915
1916	clk_prepare_lock();
1917	accuracy = clk_core_get_accuracy_recalc(core: clk->core);
1918	clk_prepare_unlock();
1919
1920	return accuracy;
1921	}
1922	EXPORT_SYMBOL_GPL(clk_get_accuracy);
1923
1924	static unsigned long clk_recalc(struct clk_core *core,
1925	unsigned long parent_rate)
1926	{
1927	unsigned long rate = parent_rate;
1928
1929	if (core->ops->recalc_rate && !clk_pm_runtime_get(core)) {
1930	rate = core->ops->recalc_rate(core->hw, parent_rate);
1931	clk_pm_runtime_put(core);
1932	}
1933	return rate;
1934	}
1935
1936	/**
1937	* __clk_recalc_rates
1938	* @core: first clk in the subtree
1939	* @update_req: Whether req_rate should be updated with the new rate
1940	* @msg: notification type (see include/linux/clk.h)
1941	*
1942	* Walks the subtree of clks starting with clk and recalculates rates as it
1943	* goes. Note that if a clk does not implement the .recalc_rate callback then
1944	* it is assumed that the clock will take on the rate of its parent.
1945	*
1946	* clk_recalc_rates also propagates the POST_RATE_CHANGE notification,
1947	* if necessary.
1948	*/
1949	static void __clk_recalc_rates(struct clk_core *core, bool update_req,
1950	unsigned long msg)
1951	{
1952	unsigned long old_rate;
1953	unsigned long parent_rate = 0;
1954	struct clk_core *child;
1955
1956	lockdep_assert_held(&prepare_lock);
1957
1958	old_rate = core->rate;
1959
1960	if (core->parent)
1961	parent_rate = core->parent->rate;
1962
1963	core->rate = clk_recalc(core, parent_rate);
1964	if (update_req)
1965	core->req_rate = core->rate;
1966
1967	/*
1968	* ignore NOTIFY_STOP and NOTIFY_BAD return values for POST_RATE_CHANGE
1969	* & ABORT_RATE_CHANGE notifiers
1970	*/
1971	if (core->notifier_count && msg)
1972	__clk_notify(core, msg, old_rate, new_rate: core->rate);
1973
1974	hlist_for_each_entry(child, &core->children, child_node)
1975	__clk_recalc_rates(core: child, update_req, msg);
1976	}
1977
1978	static unsigned long clk_core_get_rate_recalc(struct clk_core *core)
1979	{
1980	if (core && (core->flags & CLK_GET_RATE_NOCACHE))
1981	__clk_recalc_rates(core, update_req: false, msg: 0);
1982
1983	return clk_core_get_rate_nolock(core);
1984	}
1985
1986	/**
1987	* clk_get_rate - return the rate of clk
1988	* @clk: the clk whose rate is being returned
1989	*
1990	* Simply returns the cached rate of the clk, unless CLK_GET_RATE_NOCACHE flag
1991	* is set, which means a recalc_rate will be issued. Can be called regardless of
1992	* the clock enabledness. If clk is NULL, or if an error occurred, then returns
1993	* 0.
1994	*/
1995	unsigned long clk_get_rate(struct clk *clk)
1996	{
1997	unsigned long rate;
1998
1999	if (!clk)
2000	return 0;
2001
2002	clk_prepare_lock();
2003	rate = clk_core_get_rate_recalc(core: clk->core);
2004	clk_prepare_unlock();
2005
2006	return rate;
2007	}
2008	EXPORT_SYMBOL_GPL(clk_get_rate);
2009
2010	static int clk_fetch_parent_index(struct clk_core *core,
2011	struct clk_core *parent)
2012	{
2013	int i;
2014
2015	if (!parent)
2016	return -EINVAL;
2017
2018	for (i = 0; i < core->num_parents; i++) {
2019	/* Found it first try! */
2020	if (core->parents[i].core == parent)
2021	return i;
2022
2023	/* Something else is here, so keep looking */
2024	if (core->parents[i].core)
2025	continue;
2026
2027	/* Maybe core hasn't been cached but the hw is all we know? */
2028	if (core->parents[i].hw) {
2029	if (core->parents[i].hw == parent->hw)
2030	break;
2031
2032	/* Didn't match, but we're expecting a clk_hw */
2033	continue;
2034	}
2035
2036	/* Maybe it hasn't been cached (clk_set_parent() path) */
2037	if (parent == clk_core_get(core, p_index: i))
2038	break;
2039
2040	/* Fallback to comparing globally unique names */
2041	if (core->parents[i].name &&
2042	!strcmp(parent->name, core->parents[i].name))
2043	break;
2044	}
2045
2046	if (i == core->num_parents)
2047	return -EINVAL;
2048
2049	core->parents[i].core = parent;
2050	return i;
2051	}
2052
2053	/**
2054	* clk_hw_get_parent_index - return the index of the parent clock
2055	* @hw: clk_hw associated with the clk being consumed
2056	*
2057	* Fetches and returns the index of parent clock. Returns -EINVAL if the given
2058	* clock does not have a current parent.
2059	*/
2060	int clk_hw_get_parent_index(struct clk_hw *hw)
2061	{
2062	struct clk_hw *parent = clk_hw_get_parent(hw);
2063
2064	if (WARN_ON(parent == NULL))
2065	return -EINVAL;
2066
2067	return clk_fetch_parent_index(core: hw->core, parent: parent->core);
2068	}
2069	EXPORT_SYMBOL_GPL(clk_hw_get_parent_index);
2070
2071	/*
2072	* Update the orphan status of @core and all its children.
2073	*/
2074	static void clk_core_update_orphan_status(struct clk_core *core, bool is_orphan)
2075	{
2076	struct clk_core *child;
2077
2078	core->orphan = is_orphan;
2079
2080	hlist_for_each_entry(child, &core->children, child_node)
2081	clk_core_update_orphan_status(core: child, is_orphan);
2082	}
2083
2084	static void clk_reparent(struct clk_core *core, struct clk_core *new_parent)
2085	{
2086	bool was_orphan = core->orphan;
2087
2088	hlist_del(n: &core->child_node);
2089
2090	if (new_parent) {
2091	bool becomes_orphan = new_parent->orphan;
2092
2093	/* avoid duplicate POST_RATE_CHANGE notifications */
2094	if (new_parent->new_child == core)
2095	new_parent->new_child = NULL;
2096
2097	hlist_add_head(n: &core->child_node, h: &new_parent->children);
2098
2099	if (was_orphan != becomes_orphan)
2100	clk_core_update_orphan_status(core, is_orphan: becomes_orphan);
2101	} else {
2102	hlist_add_head(n: &core->child_node, h: &clk_orphan_list);
2103	if (!was_orphan)
2104	clk_core_update_orphan_status(core, is_orphan: true);
2105	}
2106
2107	core->parent = new_parent;
2108	}
2109
2110	static struct clk_core *__clk_set_parent_before(struct clk_core *core,
2111	struct clk_core *parent)
2112	{
2113	unsigned long flags;
2114	struct clk_core *old_parent = core->parent;
2115
2116	/*
2117	* 1. enable parents for CLK_OPS_PARENT_ENABLE clock
2118	*
2119	* 2. Migrate prepare state between parents and prevent race with
2120	* clk_enable().
2121	*
2122	* If the clock is not prepared, then a race with
2123	* clk_enable/disable() is impossible since we already have the
2124	* prepare lock (future calls to clk_enable() need to be preceded by
2125	* a clk_prepare()).
2126	*
2127	* If the clock is prepared, migrate the prepared state to the new
2128	* parent and also protect against a race with clk_enable() by
2129	* forcing the clock and the new parent on. This ensures that all
2130	* future calls to clk_enable() are practically NOPs with respect to
2131	* hardware and software states.
2132	*
2133	* See also: Comment for clk_set_parent() below.
2134	*/
2135
2136	/* enable old_parent & parent if CLK_OPS_PARENT_ENABLE is set */
2137	if (core->flags & CLK_OPS_PARENT_ENABLE) {
2138	clk_core_prepare_enable(core: old_parent);
2139	clk_core_prepare_enable(core: parent);
2140	}
2141
2142	/* migrate prepare count if > 0 */
2143	if (core->prepare_count) {
2144	clk_core_prepare_enable(core: parent);
2145	clk_core_enable_lock(core);
2146	}
2147
2148	/* update the clk tree topology */
2149	flags = clk_enable_lock();
2150	clk_reparent(core, new_parent: parent);
2151	clk_enable_unlock(flags);
2152
2153	return old_parent;
2154	}
2155
2156	static void __clk_set_parent_after(struct clk_core *core,
2157	struct clk_core *parent,
2158	struct clk_core *old_parent)
2159	{
2160	/*
2161	* Finish the migration of prepare state and undo the changes done
2162	* for preventing a race with clk_enable().
2163	*/
2164	if (core->prepare_count) {
2165	clk_core_disable_lock(core);
2166	clk_core_disable_unprepare(core: old_parent);
2167	}
2168
2169	/* re-balance ref counting if CLK_OPS_PARENT_ENABLE is set */
2170	if (core->flags & CLK_OPS_PARENT_ENABLE) {
2171	clk_core_disable_unprepare(core: parent);
2172	clk_core_disable_unprepare(core: old_parent);
2173	}
2174	}
2175
2176	static int __clk_set_parent(struct clk_core *core, struct clk_core *parent,
2177	u8 p_index)
2178	{
2179	unsigned long flags;
2180	int ret = 0;
2181	struct clk_core *old_parent;
2182
2183	old_parent = __clk_set_parent_before(core, parent);
2184
2185	trace_clk_set_parent(core, parent);
2186
2187	/* change clock input source */
2188	if (parent && core->ops->set_parent)
2189	ret = core->ops->set_parent(core->hw, p_index);
2190
2191	trace_clk_set_parent_complete(core, parent);
2192
2193	if (ret) {
2194	flags = clk_enable_lock();
2195	clk_reparent(core, new_parent: old_parent);
2196	clk_enable_unlock(flags);
2197
2198	__clk_set_parent_after(core, parent: old_parent, old_parent: parent);
2199
2200	return ret;
2201	}
2202
2203	__clk_set_parent_after(core, parent, old_parent);
2204
2205	return 0;
2206	}
2207
2208	/**
2209	* __clk_speculate_rates
2210	* @core: first clk in the subtree
2211	* @parent_rate: the "future" rate of clk's parent
2212	*
2213	* Walks the subtree of clks starting with clk, speculating rates as it
2214	* goes and firing off PRE_RATE_CHANGE notifications as necessary.
2215	*
2216	* Unlike clk_recalc_rates, clk_speculate_rates exists only for sending
2217	* pre-rate change notifications and returns early if no clks in the
2218	* subtree have subscribed to the notifications. Note that if a clk does not
2219	* implement the .recalc_rate callback then it is assumed that the clock will
2220	* take on the rate of its parent.
2221	*/
2222	static int __clk_speculate_rates(struct clk_core *core,
2223	unsigned long parent_rate)
2224	{
2225	struct clk_core *child;
2226	unsigned long new_rate;
2227	int ret = NOTIFY_DONE;
2228
2229	lockdep_assert_held(&prepare_lock);
2230
2231	new_rate = clk_recalc(core, parent_rate);
2232
2233	/* abort rate change if a driver returns NOTIFY_BAD or NOTIFY_STOP */
2234	if (core->notifier_count)
2235	ret = __clk_notify(core, PRE_RATE_CHANGE, old_rate: core->rate, new_rate);
2236
2237	if (ret & NOTIFY_STOP_MASK) {
2238	pr_debug("%s: clk notifier callback for clock %s aborted with error %d\n",
2239	__func__, core->name, ret);
2240	goto out;
2241	}
2242
2243	hlist_for_each_entry(child, &core->children, child_node) {
2244	ret = __clk_speculate_rates(core: child, parent_rate: new_rate);
2245	if (ret & NOTIFY_STOP_MASK)
2246	break;
2247	}
2248
2249	out:
2250	return ret;
2251	}
2252
2253	static void clk_calc_subtree(struct clk_core *core, unsigned long new_rate,
2254	struct clk_core *new_parent, u8 p_index)
2255	{
2256	struct clk_core *child;
2257
2258	core->new_rate = new_rate;
2259	core->new_parent = new_parent;
2260	core->new_parent_index = p_index;
2261	/* include clk in new parent's PRE_RATE_CHANGE notifications */
2262	core->new_child = NULL;
2263	if (new_parent && new_parent != core->parent)
2264	new_parent->new_child = core;
2265
2266	hlist_for_each_entry(child, &core->children, child_node) {
2267	child->new_rate = clk_recalc(core: child, parent_rate: new_rate);
2268	clk_calc_subtree(core: child, new_rate: child->new_rate, NULL, p_index: 0);
2269	}
2270	}
2271
2272	/*
2273	* calculate the new rates returning the topmost clock that has to be
2274	* changed.
2275	*/
2276	static struct clk_core *clk_calc_new_rates(struct clk_core *core,
2277	unsigned long rate)
2278	{
2279	struct clk_core *top = core;
2280	struct clk_core *old_parent, *parent;
2281	unsigned long best_parent_rate = 0;
2282	unsigned long new_rate;
2283	unsigned long min_rate;
2284	unsigned long max_rate;
2285	int p_index = 0;
2286	int ret;
2287
2288	/* sanity */
2289	if (IS_ERR_OR_NULL(ptr: core))
2290	return NULL;
2291
2292	/* save parent rate, if it exists */
2293	parent = old_parent = core->parent;
2294	if (parent)
2295	best_parent_rate = parent->rate;
2296
2297	clk_core_get_boundaries(core, min_rate: &min_rate, max_rate: &max_rate);
2298
2299	/* find the closest rate and parent clk/rate */
2300	if (clk_core_can_round(core)) {
2301	struct clk_rate_request req;
2302
2303	clk_core_init_rate_req(core, req: &req, rate);
2304
2305	trace_clk_rate_request_start(req: &req);
2306
2307	ret = clk_core_determine_round_nolock(core, req: &req);
2308	if (ret < 0)
2309	return NULL;
2310
2311	trace_clk_rate_request_done(req: &req);
2312
2313	best_parent_rate = req.best_parent_rate;
2314	new_rate = req.rate;
2315	parent = req.best_parent_hw ? req.best_parent_hw->core : NULL;
2316
2317	if (new_rate < min_rate || new_rate > max_rate)
2318	return NULL;
2319	} else if (!parent || !(core->flags & CLK_SET_RATE_PARENT)) {
2320	/* pass-through clock without adjustable parent */
2321	core->new_rate = core->rate;
2322	return NULL;
2323	} else {
2324	/* pass-through clock with adjustable parent */
2325	top = clk_calc_new_rates(core: parent, rate);
2326	new_rate = parent->new_rate;
2327	goto out;
2328	}
2329
2330	/* some clocks must be gated to change parent */
2331	if (parent != old_parent &&
2332	(core->flags & CLK_SET_PARENT_GATE) && core->prepare_count) {
2333	pr_debug("%s: %s not gated but wants to reparent\n",
2334	__func__, core->name);
2335	return NULL;
2336	}
2337
2338	/* try finding the new parent index */
2339	if (parent && core->num_parents > 1) {
2340	p_index = clk_fetch_parent_index(core, parent);
2341	if (p_index < 0) {
2342	pr_debug("%s: clk %s can not be parent of clk %s\n",
2343	__func__, parent->name, core->name);
2344	return NULL;
2345	}
2346	}
2347
2348	if ((core->flags & CLK_SET_RATE_PARENT) && parent &&
2349	best_parent_rate != parent->rate)
2350	top = clk_calc_new_rates(core: parent, rate: best_parent_rate);
2351
2352	out:
2353	clk_calc_subtree(core, new_rate, new_parent: parent, p_index);
2354
2355	return top;
2356	}
2357
2358	/*
2359	* Notify about rate changes in a subtree. Always walk down the whole tree
2360	* so that in case of an error we can walk down the whole tree again and
2361	* abort the change.
2362	*/
2363	static struct clk_core *clk_propagate_rate_change(struct clk_core *core,
2364	unsigned long event)
2365	{
2366	struct clk_core *child, *tmp_clk, *fail_clk = NULL;
2367	int ret = NOTIFY_DONE;
2368
2369	if (core->rate == core->new_rate)
2370	return NULL;
2371
2372	if (core->notifier_count) {
2373	ret = __clk_notify(core, msg: event, old_rate: core->rate, new_rate: core->new_rate);
2374	if (ret & NOTIFY_STOP_MASK)
2375	fail_clk = core;
2376	}
2377
2378	hlist_for_each_entry(child, &core->children, child_node) {
2379	/* Skip children who will be reparented to another clock */
2380	if (child->new_parent && child->new_parent != core)
2381	continue;
2382	tmp_clk = clk_propagate_rate_change(core: child, event);
2383	if (tmp_clk)
2384	fail_clk = tmp_clk;
2385	}
2386
2387	/* handle the new child who might not be in core->children yet */
2388	if (core->new_child) {
2389	tmp_clk = clk_propagate_rate_change(core: core->new_child, event);
2390	if (tmp_clk)
2391	fail_clk = tmp_clk;
2392	}
2393
2394	return fail_clk;
2395	}
2396
2397	/*
2398	* walk down a subtree and set the new rates notifying the rate
2399	* change on the way
2400	*/
2401	static void clk_change_rate(struct clk_core *core)
2402	{
2403	struct clk_core *child;
2404	struct hlist_node *tmp;
2405	unsigned long old_rate;
2406	unsigned long best_parent_rate = 0;
2407	bool skip_set_rate = false;
2408	struct clk_core *old_parent;
2409	struct clk_core *parent = NULL;
2410
2411	old_rate = core->rate;
2412
2413	if (core->new_parent) {
2414	parent = core->new_parent;
2415	best_parent_rate = core->new_parent->rate;
2416	} else if (core->parent) {
2417	parent = core->parent;
2418	best_parent_rate = core->parent->rate;
2419	}
2420
2421	if (clk_pm_runtime_get(core))
2422	return;
2423
2424	if (core->flags & CLK_SET_RATE_UNGATE) {
2425	clk_core_prepare(core);
2426	clk_core_enable_lock(core);
2427	}
2428
2429	if (core->new_parent && core->new_parent != core->parent) {
2430	old_parent = __clk_set_parent_before(core, parent: core->new_parent);
2431	trace_clk_set_parent(core, parent: core->new_parent);
2432
2433	if (core->ops->set_rate_and_parent) {
2434	skip_set_rate = true;
2435	core->ops->set_rate_and_parent(core->hw, core->new_rate,
2436	best_parent_rate,
2437	core->new_parent_index);
2438	} else if (core->ops->set_parent) {
2439	core->ops->set_parent(core->hw, core->new_parent_index);
2440	}
2441
2442	trace_clk_set_parent_complete(core, parent: core->new_parent);
2443	__clk_set_parent_after(core, parent: core->new_parent, old_parent);
2444	}
2445
2446	if (core->flags & CLK_OPS_PARENT_ENABLE)
2447	clk_core_prepare_enable(core: parent);
2448
2449	trace_clk_set_rate(core, rate: core->new_rate);
2450
2451	if (!skip_set_rate && core->ops->set_rate)
2452	core->ops->set_rate(core->hw, core->new_rate, best_parent_rate);
2453
2454	trace_clk_set_rate_complete(core, rate: core->new_rate);
2455
2456	core->rate = clk_recalc(core, parent_rate: best_parent_rate);
2457
2458	if (core->flags & CLK_SET_RATE_UNGATE) {
2459	clk_core_disable_lock(core);
2460	clk_core_unprepare(core);
2461	}
2462
2463	if (core->flags & CLK_OPS_PARENT_ENABLE)
2464	clk_core_disable_unprepare(core: parent);
2465
2466	if (core->notifier_count && old_rate != core->rate)
2467	__clk_notify(core, POST_RATE_CHANGE, old_rate, new_rate: core->rate);
2468
2469	if (core->flags & CLK_RECALC_NEW_RATES)
2470	(void)clk_calc_new_rates(core, rate: core->new_rate);
2471
2472	/*
2473	* Use safe iteration, as change_rate can actually swap parents
2474	* for certain clock types.
2475	*/
2476	hlist_for_each_entry_safe(child, tmp, &core->children, child_node) {
2477	/* Skip children who will be reparented to another clock */
2478	if (child->new_parent && child->new_parent != core)
2479	continue;
2480	clk_change_rate(core: child);
2481	}
2482
2483	/* handle the new child who might not be in core->children yet */
2484	if (core->new_child)
2485	clk_change_rate(core: core->new_child);
2486
2487	clk_pm_runtime_put(core);
2488	}
2489
2490	static unsigned long clk_core_req_round_rate_nolock(struct clk_core *core,
2491	unsigned long req_rate)
2492	{
2493	int ret, cnt;
2494	struct clk_rate_request req;
2495
2496	lockdep_assert_held(&prepare_lock);
2497
2498	if (!core)
2499	return 0;
2500
2501	/* simulate what the rate would be if it could be freely set */
2502	cnt = clk_core_rate_nuke_protect(core);
2503	if (cnt < 0)
2504	return cnt;
2505
2506	clk_core_init_rate_req(core, req: &req, rate: req_rate);
2507
2508	trace_clk_rate_request_start(req: &req);
2509
2510	ret = clk_core_round_rate_nolock(core, req: &req);
2511
2512	trace_clk_rate_request_done(req: &req);
2513
2514	/* restore the protection */
2515	clk_core_rate_restore_protect(core, count: cnt);
2516
2517	return ret ? 0 : req.rate;
2518	}
2519
2520	static int clk_core_set_rate_nolock(struct clk_core *core,
2521	unsigned long req_rate)
2522	{
2523	struct clk_core *top, *fail_clk;
2524	unsigned long rate;
2525	int ret;
2526
2527	if (!core)
2528	return 0;
2529
2530	rate = clk_core_req_round_rate_nolock(core, req_rate);
2531
2532	/* bail early if nothing to do */
2533	if (rate == clk_core_get_rate_nolock(core))
2534	return 0;
2535
2536	/* fail on a direct rate set of a protected provider */
2537	if (clk_core_rate_is_protected(core))
2538	return -EBUSY;
2539
2540	/* calculate new rates and get the topmost changed clock */
2541	top = clk_calc_new_rates(core, rate: req_rate);
2542	if (!top)
2543	return -EINVAL;
2544
2545	ret = clk_pm_runtime_get(core);
2546	if (ret)
2547	return ret;
2548
2549	/* notify that we are about to change rates */
2550	fail_clk = clk_propagate_rate_change(core: top, PRE_RATE_CHANGE);
2551	if (fail_clk) {
2552	pr_debug("%s: failed to set %s rate\n", __func__,
2553	fail_clk->name);
2554	clk_propagate_rate_change(core: top, ABORT_RATE_CHANGE);
2555	ret = -EBUSY;
2556	goto err;
2557	}
2558
2559	/* change the rates */
2560	clk_change_rate(core: top);
2561
2562	core->req_rate = req_rate;
2563	err:
2564	clk_pm_runtime_put(core);
2565
2566	return ret;
2567	}
2568
2569	/**
2570	* clk_set_rate - specify a new rate for clk
2571	* @clk: the clk whose rate is being changed
2572	* @rate: the new rate for clk
2573	*
2574	* In the simplest case clk_set_rate will only adjust the rate of clk.
2575	*
2576	* Setting the CLK_SET_RATE_PARENT flag allows the rate change operation to
2577	* propagate up to clk's parent; whether or not this happens depends on the
2578	* outcome of clk's .round_rate implementation. If *parent_rate is unchanged
2579	* after calling .round_rate then upstream parent propagation is ignored. If
2580	* *parent_rate comes back with a new rate for clk's parent then we propagate
2581	* up to clk's parent and set its rate. Upward propagation will continue
2582	* until either a clk does not support the CLK_SET_RATE_PARENT flag or
2583	* .round_rate stops requesting changes to clk's parent_rate.
2584	*
2585	* Rate changes are accomplished via tree traversal that also recalculates the
2586	* rates for the clocks and fires off POST_RATE_CHANGE notifiers.
2587	*
2588	* Returns 0 on success, -EERROR otherwise.
2589	*/
2590	int clk_set_rate(struct clk *clk, unsigned long rate)
2591	{
2592	int ret;
2593
2594	if (!clk)
2595	return 0;
2596
2597	/* prevent racing with updates to the clock topology */
2598	clk_prepare_lock();
2599
2600	if (clk->exclusive_count)
2601	clk_core_rate_unprotect(core: clk->core);
2602
2603	ret = clk_core_set_rate_nolock(core: clk->core, req_rate: rate);
2604
2605	if (clk->exclusive_count)
2606	clk_core_rate_protect(core: clk->core);
2607
2608	clk_prepare_unlock();
2609
2610	return ret;
2611	}
2612	EXPORT_SYMBOL_GPL(clk_set_rate);
2613
2614	/**
2615	* clk_set_rate_exclusive - specify a new rate and get exclusive control
2616	* @clk: the clk whose rate is being changed
2617	* @rate: the new rate for clk
2618	*
2619	* This is a combination of clk_set_rate() and clk_rate_exclusive_get()
2620	* within a critical section
2621	*
2622	* This can be used initially to ensure that at least 1 consumer is
2623	* satisfied when several consumers are competing for exclusivity over the
2624	* same clock provider.
2625	*
2626	* The exclusivity is not applied if setting the rate failed.
2627	*
2628	* Calls to clk_rate_exclusive_get() should be balanced with calls to
2629	* clk_rate_exclusive_put().
2630	*
2631	* Returns 0 on success, -EERROR otherwise.
2632	*/
2633	int clk_set_rate_exclusive(struct clk *clk, unsigned long rate)
2634	{
2635	int ret;
2636
2637	if (!clk)
2638	return 0;
2639
2640	/* prevent racing with updates to the clock topology */
2641	clk_prepare_lock();
2642
2643	/*
2644	* The temporary protection removal is not here, on purpose
2645	* This function is meant to be used instead of clk_rate_protect,
2646	* so before the consumer code path protect the clock provider
2647	*/
2648
2649	ret = clk_core_set_rate_nolock(core: clk->core, req_rate: rate);
2650	if (!ret) {
2651	clk_core_rate_protect(core: clk->core);
2652	clk->exclusive_count++;
2653	}
2654
2655	clk_prepare_unlock();
2656
2657	return ret;
2658	}
2659	EXPORT_SYMBOL_GPL(clk_set_rate_exclusive);
2660
2661	static int clk_set_rate_range_nolock(struct clk *clk,
2662	unsigned long min,
2663	unsigned long max)
2664	{
2665	int ret = 0;
2666	unsigned long old_min, old_max, rate;
2667
2668	lockdep_assert_held(&prepare_lock);
2669
2670	if (!clk)
2671	return 0;
2672
2673	trace_clk_set_rate_range(core: clk->core, min, max);
2674
2675	if (min > max) {
2676	pr_err("%s: clk %s dev %s con %s: invalid range [%lu, %lu]\n",
2677	__func__, clk->core->name, clk->dev_id, clk->con_id,
2678	min, max);
2679	return -EINVAL;
2680	}
2681
2682	if (clk->exclusive_count)
2683	clk_core_rate_unprotect(core: clk->core);
2684
2685	/* Save the current values in case we need to rollback the change */
2686	old_min = clk->min_rate;
2687	old_max = clk->max_rate;
2688	clk->min_rate = min;
2689	clk->max_rate = max;
2690
2691	if (!clk_core_check_boundaries(core: clk->core, min_rate: min, max_rate: max)) {
2692	ret = -EINVAL;
2693	goto out;
2694	}
2695
2696	rate = clk->core->req_rate;
2697	if (clk->core->flags & CLK_GET_RATE_NOCACHE)
2698	rate = clk_core_get_rate_recalc(core: clk->core);
2699
2700	/*
2701	* Since the boundaries have been changed, let's give the
2702	* opportunity to the provider to adjust the clock rate based on
2703	* the new boundaries.
2704	*
2705	* We also need to handle the case where the clock is currently
2706	* outside of the boundaries. Clamping the last requested rate
2707	* to the current minimum and maximum will also handle this.
2708	*
2709	* FIXME:
2710	* There is a catch. It may fail for the usual reason (clock
2711	* broken, clock protected, etc) but also because:
2712	* - round_rate() was not favorable and fell on the wrong
2713	* side of the boundary
2714	* - the determine_rate() callback does not really check for
2715	* this corner case when determining the rate
2716	*/
2717	rate = clamp(rate, min, max);
2718	ret = clk_core_set_rate_nolock(core: clk->core, req_rate: rate);
2719	if (ret) {
2720	/* rollback the changes */
2721	clk->min_rate = old_min;
2722	clk->max_rate = old_max;
2723	}
2724
2725	out:
2726	if (clk->exclusive_count)
2727	clk_core_rate_protect(core: clk->core);
2728
2729	return ret;
2730	}
2731
2732	/**
2733	* clk_set_rate_range - set a rate range for a clock source
2734	* @clk: clock source
2735	* @min: desired minimum clock rate in Hz, inclusive
2736	* @max: desired maximum clock rate in Hz, inclusive
2737	*
2738	* Return: 0 for success or negative errno on failure.
2739	*/
2740	int clk_set_rate_range(struct clk *clk, unsigned long min, unsigned long max)
2741	{
2742	int ret;
2743
2744	if (!clk)
2745	return 0;
2746
2747	clk_prepare_lock();
2748
2749	ret = clk_set_rate_range_nolock(clk, min, max);
2750
2751	clk_prepare_unlock();
2752
2753	return ret;
2754	}
2755	EXPORT_SYMBOL_GPL(clk_set_rate_range);
2756
2757	/**
2758	* clk_set_min_rate - set a minimum clock rate for a clock source
2759	* @clk: clock source
2760	* @rate: desired minimum clock rate in Hz, inclusive
2761	*
2762	* Returns success (0) or negative errno.
2763	*/
2764	int clk_set_min_rate(struct clk *clk, unsigned long rate)
2765	{
2766	if (!clk)
2767	return 0;
2768
2769	trace_clk_set_min_rate(core: clk->core, rate);
2770
2771	return clk_set_rate_range(clk, rate, clk->max_rate);
2772	}
2773	EXPORT_SYMBOL_GPL(clk_set_min_rate);
2774
2775	/**
2776	* clk_set_max_rate - set a maximum clock rate for a clock source
2777	* @clk: clock source
2778	* @rate: desired maximum clock rate in Hz, inclusive
2779	*
2780	* Returns success (0) or negative errno.
2781	*/
2782	int clk_set_max_rate(struct clk *clk, unsigned long rate)
2783	{
2784	if (!clk)
2785	return 0;
2786
2787	trace_clk_set_max_rate(core: clk->core, rate);
2788
2789	return clk_set_rate_range(clk, clk->min_rate, rate);
2790	}
2791	EXPORT_SYMBOL_GPL(clk_set_max_rate);
2792
2793	/**
2794	* clk_get_parent - return the parent of a clk
2795	* @clk: the clk whose parent gets returned
2796	*
2797	* Simply returns clk->parent. Returns NULL if clk is NULL.
2798	*/
2799	struct clk *clk_get_parent(struct clk *clk)
2800	{
2801	struct clk *parent;
2802
2803	if (!clk)
2804	return NULL;
2805
2806	clk_prepare_lock();
2807	/* TODO: Create a per-user clk and change callers to call clk_put */
2808	parent = !clk->core->parent ? NULL : clk->core->parent->hw->clk;
2809	clk_prepare_unlock();
2810
2811	return parent;
2812	}
2813	EXPORT_SYMBOL_GPL(clk_get_parent);
2814
2815	static struct clk_core *__clk_init_parent(struct clk_core *core)
2816	{
2817	u8 index = 0;
2818
2819	if (core->num_parents > 1 && core->ops->get_parent)
2820	index = core->ops->get_parent(core->hw);
2821
2822	return clk_core_get_parent_by_index(core, index);
2823	}
2824
2825	static void clk_core_reparent(struct clk_core *core,
2826	struct clk_core *new_parent)
2827	{
2828	clk_reparent(core, new_parent);
2829	__clk_recalc_accuracies(core);
2830	__clk_recalc_rates(core, update_req: true, POST_RATE_CHANGE);
2831	}
2832
2833	void clk_hw_reparent(struct clk_hw *hw, struct clk_hw *new_parent)
2834	{
2835	if (!hw)
2836	return;
2837
2838	clk_core_reparent(core: hw->core, new_parent: !new_parent ? NULL : new_parent->core);
2839	}
2840
2841	/**
2842	* clk_has_parent - check if a clock is a possible parent for another
2843	* @clk: clock source
2844	* @parent: parent clock source
2845	*
2846	* This function can be used in drivers that need to check that a clock can be
2847	* the parent of another without actually changing the parent.
2848	*
2849	* Returns true if @parent is a possible parent for @clk, false otherwise.
2850	*/
2851	bool clk_has_parent(const struct clk *clk, const struct clk *parent)
2852	{
2853	/* NULL clocks should be nops, so return success if either is NULL. */
2854	if (!clk || !parent)
2855	return true;
2856
2857	return clk_core_has_parent(core: clk->core, parent: parent->core);
2858	}
2859	EXPORT_SYMBOL_GPL(clk_has_parent);
2860
2861	static int clk_core_set_parent_nolock(struct clk_core *core,
2862	struct clk_core *parent)
2863	{
2864	int ret = 0;
2865	int p_index = 0;
2866	unsigned long p_rate = 0;
2867
2868	lockdep_assert_held(&prepare_lock);
2869
2870	if (!core)
2871	return 0;
2872
2873	if (core->parent == parent)
2874	return 0;
2875
2876	/* verify ops for multi-parent clks */
2877	if (core->num_parents > 1 && !core->ops->set_parent)
2878	return -EPERM;
2879
2880	/* check that we are allowed to re-parent if the clock is in use */
2881	if ((core->flags & CLK_SET_PARENT_GATE) && core->prepare_count)
2882	return -EBUSY;
2883
2884	if (clk_core_rate_is_protected(core))
2885	return -EBUSY;
2886
2887	/* try finding the new parent index */
2888	if (parent) {
2889	p_index = clk_fetch_parent_index(core, parent);
2890	if (p_index < 0) {
2891	pr_debug("%s: clk %s can not be parent of clk %s\n",
2892	__func__, parent->name, core->name);
2893	return p_index;
2894	}
2895	p_rate = parent->rate;
2896	}
2897
2898	ret = clk_pm_runtime_get(core);
2899	if (ret)
2900	return ret;
2901
2902	/* propagate PRE_RATE_CHANGE notifications */
2903	ret = __clk_speculate_rates(core, parent_rate: p_rate);
2904
2905	/* abort if a driver objects */
2906	if (ret & NOTIFY_STOP_MASK)
2907	goto runtime_put;
2908
2909	/* do the re-parent */
2910	ret = __clk_set_parent(core, parent, p_index);
2911
2912	/* propagate rate an accuracy recalculation accordingly */
2913	if (ret) {
2914	__clk_recalc_rates(core, update_req: true, ABORT_RATE_CHANGE);
2915	} else {
2916	__clk_recalc_rates(core, update_req: true, POST_RATE_CHANGE);
2917	__clk_recalc_accuracies(core);
2918	}
2919
2920	runtime_put:
2921	clk_pm_runtime_put(core);
2922
2923	return ret;
2924	}
2925
2926	int clk_hw_set_parent(struct clk_hw *hw, struct clk_hw *parent)
2927	{
2928	return clk_core_set_parent_nolock(core: hw->core, parent: parent->core);
2929	}
2930	EXPORT_SYMBOL_GPL(clk_hw_set_parent);
2931
2932	/**
2933	* clk_set_parent - switch the parent of a mux clk
2934	* @clk: the mux clk whose input we are switching
2935	* @parent: the new input to clk
2936	*
2937	* Re-parent clk to use parent as its new input source. If clk is in
2938	* prepared state, the clk will get enabled for the duration of this call. If
2939	* that's not acceptable for a specific clk (Eg: the consumer can't handle
2940	* that, the reparenting is glitchy in hardware, etc), use the
2941	* CLK_SET_PARENT_GATE flag to allow reparenting only when clk is unprepared.
2942	*
2943	* After successfully changing clk's parent clk_set_parent will update the
2944	* clk topology, sysfs topology and propagate rate recalculation via
2945	* __clk_recalc_rates.
2946	*
2947	* Returns 0 on success, -EERROR otherwise.
2948	*/
2949	int clk_set_parent(struct clk *clk, struct clk *parent)
2950	{
2951	int ret;
2952
2953	if (!clk)
2954	return 0;
2955
2956	clk_prepare_lock();
2957
2958	if (clk->exclusive_count)
2959	clk_core_rate_unprotect(core: clk->core);
2960
2961	ret = clk_core_set_parent_nolock(core: clk->core,
2962	parent: parent ? parent->core : NULL);
2963
2964	if (clk->exclusive_count)
2965	clk_core_rate_protect(core: clk->core);
2966
2967	clk_prepare_unlock();
2968
2969	return ret;
2970	}
2971	EXPORT_SYMBOL_GPL(clk_set_parent);
2972
2973	static int clk_core_set_phase_nolock(struct clk_core *core, int degrees)
2974	{
2975	int ret = -EINVAL;
2976
2977	lockdep_assert_held(&prepare_lock);
2978
2979	if (!core)
2980	return 0;
2981
2982	if (clk_core_rate_is_protected(core))
2983	return -EBUSY;
2984
2985	trace_clk_set_phase(core, phase: degrees);
2986
2987	if (core->ops->set_phase) {
2988	ret = core->ops->set_phase(core->hw, degrees);
2989	if (!ret)
2990	core->phase = degrees;
2991	}
2992
2993	trace_clk_set_phase_complete(core, phase: degrees);
2994
2995	return ret;
2996	}
2997
2998	/**
2999	* clk_set_phase - adjust the phase shift of a clock signal
3000	* @clk: clock signal source
3001	* @degrees: number of degrees the signal is shifted
3002	*
3003	* Shifts the phase of a clock signal by the specified
3004	* degrees. Returns 0 on success, -EERROR otherwise.
3005	*
3006	* This function makes no distinction about the input or reference
3007	* signal that we adjust the clock signal phase against. For example
3008	* phase locked-loop clock signal generators we may shift phase with
3009	* respect to feedback clock signal input, but for other cases the
3010	* clock phase may be shifted with respect to some other, unspecified
3011	* signal.
3012	*
3013	* Additionally the concept of phase shift does not propagate through
3014	* the clock tree hierarchy, which sets it apart from clock rates and
3015	* clock accuracy. A parent clock phase attribute does not have an
3016	* impact on the phase attribute of a child clock.
3017	*/
3018	int clk_set_phase(struct clk *clk, int degrees)
3019	{
3020	int ret;
3021
3022	if (!clk)
3023	return 0;
3024
3025	/* sanity check degrees */
3026	degrees %= 360;
3027	if (degrees < 0)
3028	degrees += 360;
3029
3030	clk_prepare_lock();
3031
3032	if (clk->exclusive_count)
3033	clk_core_rate_unprotect(core: clk->core);
3034
3035	ret = clk_core_set_phase_nolock(core: clk->core, degrees);
3036
3037	if (clk->exclusive_count)
3038	clk_core_rate_protect(core: clk->core);
3039
3040	clk_prepare_unlock();
3041
3042	return ret;
3043	}
3044	EXPORT_SYMBOL_GPL(clk_set_phase);
3045
3046	static int clk_core_get_phase(struct clk_core *core)
3047	{
3048	int ret;
3049
3050	lockdep_assert_held(&prepare_lock);
3051	if (!core->ops->get_phase)
3052	return 0;
3053
3054	/* Always try to update cached phase if possible */
3055	ret = core->ops->get_phase(core->hw);
3056	if (ret >= 0)
3057	core->phase = ret;
3058
3059	return ret;
3060	}
3061
3062	/**
3063	* clk_get_phase - return the phase shift of a clock signal
3064	* @clk: clock signal source
3065	*
3066	* Returns the phase shift of a clock node in degrees, otherwise returns
3067	* -EERROR.
3068	*/
3069	int clk_get_phase(struct clk *clk)
3070	{
3071	int ret;
3072
3073	if (!clk)
3074	return 0;
3075
3076	clk_prepare_lock();
3077	ret = clk_core_get_phase(core: clk->core);
3078	clk_prepare_unlock();
3079
3080	return ret;
3081	}
3082	EXPORT_SYMBOL_GPL(clk_get_phase);
3083
3084	static void clk_core_reset_duty_cycle_nolock(struct clk_core *core)
3085	{
3086	/* Assume a default value of 50% */
3087	core->duty.num = 1;
3088	core->duty.den = 2;
3089	}
3090
3091	static int clk_core_update_duty_cycle_parent_nolock(struct clk_core *core);
3092
3093	static int clk_core_update_duty_cycle_nolock(struct clk_core *core)
3094	{
3095	struct clk_duty *duty = &core->duty;
3096	int ret = 0;
3097
3098	if (!core->ops->get_duty_cycle)
3099	return clk_core_update_duty_cycle_parent_nolock(core);
3100
3101	ret = core->ops->get_duty_cycle(core->hw, duty);
3102	if (ret)
3103	goto reset;
3104
3105	/* Don't trust the clock provider too much */
3106	if (duty->den == 0 || duty->num > duty->den) {
3107	ret = -EINVAL;
3108	goto reset;
3109	}
3110
3111	return 0;
3112
3113	reset:
3114	clk_core_reset_duty_cycle_nolock(core);
3115	return ret;
3116	}
3117
3118	static int clk_core_update_duty_cycle_parent_nolock(struct clk_core *core)
3119	{
3120	int ret = 0;
3121
3122	if (core->parent &&
3123	core->flags & CLK_DUTY_CYCLE_PARENT) {
3124	ret = clk_core_update_duty_cycle_nolock(core: core->parent);
3125	memcpy(&core->duty, &core->parent->duty, sizeof(core->duty));
3126	} else {
3127	clk_core_reset_duty_cycle_nolock(core);
3128	}
3129
3130	return ret;
3131	}
3132
3133	static int clk_core_set_duty_cycle_parent_nolock(struct clk_core *core,
3134	struct clk_duty *duty);
3135
3136	static int clk_core_set_duty_cycle_nolock(struct clk_core *core,
3137	struct clk_duty *duty)
3138	{
3139	int ret;
3140
3141	lockdep_assert_held(&prepare_lock);
3142
3143	if (clk_core_rate_is_protected(core))
3144	return -EBUSY;
3145
3146	trace_clk_set_duty_cycle(core, duty);
3147
3148	if (!core->ops->set_duty_cycle)
3149	return clk_core_set_duty_cycle_parent_nolock(core, duty);
3150
3151	ret = core->ops->set_duty_cycle(core->hw, duty);
3152	if (!ret)
3153	memcpy(&core->duty, duty, sizeof(*duty));
3154
3155	trace_clk_set_duty_cycle_complete(core, duty);
3156
3157	return ret;
3158	}
3159
3160	static int clk_core_set_duty_cycle_parent_nolock(struct clk_core *core,
3161	struct clk_duty *duty)
3162	{
3163	int ret = 0;
3164
3165	if (core->parent &&
3166	core->flags & (CLK_DUTY_CYCLE_PARENT | CLK_SET_RATE_PARENT)) {
3167	ret = clk_core_set_duty_cycle_nolock(core: core->parent, duty);
3168	memcpy(&core->duty, &core->parent->duty, sizeof(core->duty));
3169	}
3170
3171	return ret;
3172	}
3173
3174	/**
3175	* clk_set_duty_cycle - adjust the duty cycle ratio of a clock signal
3176	* @clk: clock signal source
3177	* @num: numerator of the duty cycle ratio to be applied
3178	* @den: denominator of the duty cycle ratio to be applied
3179	*
3180	* Apply the duty cycle ratio if the ratio is valid and the clock can
3181	* perform this operation
3182	*
3183	* Returns (0) on success, a negative errno otherwise.
3184	*/
3185	int clk_set_duty_cycle(struct clk *clk, unsigned int num, unsigned int den)
3186	{
3187	int ret;
3188	struct clk_duty duty;
3189
3190	if (!clk)
3191	return 0;
3192
3193	/* sanity check the ratio */
3194	if (den == 0 || num > den)
3195	return -EINVAL;
3196
3197	duty.num = num;
3198	duty.den = den;
3199
3200	clk_prepare_lock();
3201
3202	if (clk->exclusive_count)
3203	clk_core_rate_unprotect(core: clk->core);
3204
3205	ret = clk_core_set_duty_cycle_nolock(core: clk->core, duty: &duty);
3206
3207	if (clk->exclusive_count)
3208	clk_core_rate_protect(core: clk->core);
3209
3210	clk_prepare_unlock();
3211
3212	return ret;
3213	}
3214	EXPORT_SYMBOL_GPL(clk_set_duty_cycle);
3215
3216	static int clk_core_get_scaled_duty_cycle(struct clk_core *core,
3217	unsigned int scale)
3218	{
3219	struct clk_duty *duty = &core->duty;
3220	int ret;
3221
3222	clk_prepare_lock();
3223
3224	ret = clk_core_update_duty_cycle_nolock(core);
3225	if (!ret)
3226	ret = mult_frac(scale, duty->num, duty->den);
3227
3228	clk_prepare_unlock();
3229
3230	return ret;
3231	}
3232
3233	/**
3234	* clk_get_scaled_duty_cycle - return the duty cycle ratio of a clock signal
3235	* @clk: clock signal source
3236	* @scale: scaling factor to be applied to represent the ratio as an integer
3237	*
3238	* Returns the duty cycle ratio of a clock node multiplied by the provided
3239	* scaling factor, or negative errno on error.
3240	*/
3241	int clk_get_scaled_duty_cycle(struct clk *clk, unsigned int scale)
3242	{
3243	if (!clk)
3244	return 0;
3245
3246	return clk_core_get_scaled_duty_cycle(core: clk->core, scale);
3247	}
3248	EXPORT_SYMBOL_GPL(clk_get_scaled_duty_cycle);
3249
3250	/**
3251	* clk_is_match - check if two clk's point to the same hardware clock
3252	* @p: clk compared against q
3253	* @q: clk compared against p
3254	*
3255	* Returns true if the two struct clk pointers both point to the same hardware
3256	* clock node. Put differently, returns true if struct clk *p and struct clk *q
3257	* share the same struct clk_core object.
3258	*
3259	* Returns false otherwise. Note that two NULL clks are treated as matching.
3260	*/
3261	bool clk_is_match(const struct clk *p, const struct clk *q)
3262	{
3263	/* trivial case: identical struct clk's or both NULL */
3264	if (p == q)
3265	return true;
3266
3267	/* true if clk->core pointers match. Avoid dereferencing garbage */
3268	if (!IS_ERR_OR_NULL(ptr: p) && !IS_ERR_OR_NULL(ptr: q))
3269	if (p->core == q->core)
3270	return true;
3271
3272	return false;
3273	}
3274	EXPORT_SYMBOL_GPL(clk_is_match);
3275
3276	/*** debugfs support ***/
3277
3278	#ifdef CONFIG_DEBUG_FS
3279	#include <linux/debugfs.h>
3280
3281	static struct dentry *rootdir;
3282	static int inited = 0;
3283	static DEFINE_MUTEX(clk_debug_lock);
3284	static HLIST_HEAD(clk_debug_list);
3285
3286	static struct hlist_head *orphan_list[] = {
3287	&clk_orphan_list,
3288	NULL,
3289	};
3290
3291	static void clk_summary_show_one(struct seq_file *s, struct clk_core *c,
3292	int level)
3293	{
3294	int phase;
3295	struct clk *clk_user;
3296	int multi_node = 0;
3297
3298	seq_printf(m: s, fmt: "%*s%-*s %-7d %-8d %-8d %-11lu %-10lu ",
3299	level * 3 + 1, "",
3300	35 - level * 3, c->name,
3301	c->enable_count, c->prepare_count, c->protect_count,
3302	clk_core_get_rate_recalc(core: c),
3303	clk_core_get_accuracy_recalc(core: c));
3304
3305	phase = clk_core_get_phase(core: c);
3306	if (phase >= 0)
3307	seq_printf(m: s, fmt: "%-5d", phase);
3308	else
3309	seq_puts(m: s, s: "-----");
3310
3311	seq_printf(m: s, fmt: " %-6d", clk_core_get_scaled_duty_cycle(core: c, scale: 100000));
3312
3313	if (c->ops->is_enabled)
3314	seq_printf(m: s, fmt: " %5c ", clk_core_is_enabled(core: c) ? 'Y' : 'N');
3315	else if (!c->ops->enable)
3316	seq_printf(m: s, fmt: " %5c ", 'Y');
3317	else
3318	seq_printf(m: s, fmt: " %5c ", '?');
3319
3320	hlist_for_each_entry(clk_user, &c->clks, clks_node) {
3321	seq_printf(m: s, fmt: "%*s%-*s %-25s\n",
3322	level * 3 + 2 + 105 * multi_node, "",
3323	30,
3324	clk_user->dev_id ? clk_user->dev_id : "deviceless",
3325	clk_user->con_id ? clk_user->con_id : "no_connection_id");
3326
3327	multi_node = 1;
3328	}
3329
3330	}
3331
3332	static void clk_summary_show_subtree(struct seq_file *s, struct clk_core *c,
3333	int level)
3334	{
3335	struct clk_core *child;
3336
3337	clk_summary_show_one(s, c, level);
3338
3339	hlist_for_each_entry(child, &c->children, child_node)
3340	clk_summary_show_subtree(s, c: child, level: level + 1);
3341	}
3342
3343	static int clk_summary_show(struct seq_file *s, void *data)
3344	{
3345	struct clk_core *c;
3346	struct hlist_head **lists = s->private;
3347	int ret;
3348
3349	seq_puts(m: s, s: " enable prepare protect duty hardware connection\n");
3350	seq_puts(m: s, s: " clock count count count rate accuracy phase cycle enable consumer id\n");
3351	seq_puts(m: s, s: "---------------------------------------------------------------------------------------------------------------------------------------------\n");
3352
3353	ret = clk_pm_runtime_get_all();
3354	if (ret)
3355	return ret;
3356
3357	clk_prepare_lock();
3358
3359	for (; *lists; lists++)
3360	hlist_for_each_entry(c, *lists, child_node)
3361	clk_summary_show_subtree(s, c, level: 0);
3362
3363	clk_prepare_unlock();
3364	clk_pm_runtime_put_all();
3365
3366	return 0;
3367	}
3368	DEFINE_SHOW_ATTRIBUTE(clk_summary);
3369
3370	static void clk_dump_one(struct seq_file *s, struct clk_core *c, int level)
3371	{
3372	int phase;
3373	unsigned long min_rate, max_rate;
3374
3375	clk_core_get_boundaries(core: c, min_rate: &min_rate, max_rate: &max_rate);
3376
3377	/* This should be JSON format, i.e. elements separated with a comma */
3378	seq_printf(m: s, fmt: "\"%s\": { ", c->name);
3379	seq_printf(m: s, fmt: "\"enable_count\": %d,", c->enable_count);
3380	seq_printf(m: s, fmt: "\"prepare_count\": %d,", c->prepare_count);
3381	seq_printf(m: s, fmt: "\"protect_count\": %d,", c->protect_count);
3382	seq_printf(m: s, fmt: "\"rate\": %lu,", clk_core_get_rate_recalc(core: c));
3383	seq_printf(m: s, fmt: "\"min_rate\": %lu,", min_rate);
3384	seq_printf(m: s, fmt: "\"max_rate\": %lu,", max_rate);
3385	seq_printf(m: s, fmt: "\"accuracy\": %lu,", clk_core_get_accuracy_recalc(core: c));
3386	phase = clk_core_get_phase(core: c);
3387	if (phase >= 0)
3388	seq_printf(m: s, fmt: "\"phase\": %d,", phase);
3389	seq_printf(m: s, fmt: "\"duty_cycle\": %u",
3390	clk_core_get_scaled_duty_cycle(core: c, scale: 100000));
3391	}
3392
3393	static void clk_dump_subtree(struct seq_file *s, struct clk_core *c, int level)
3394	{
3395	struct clk_core *child;
3396
3397	clk_dump_one(s, c, level);
3398
3399	hlist_for_each_entry(child, &c->children, child_node) {
3400	seq_putc(m: s, c: ',');
3401	clk_dump_subtree(s, c: child, level: level + 1);
3402	}
3403
3404	seq_putc(m: s, c: '}');
3405	}
3406
3407	static int clk_dump_show(struct seq_file *s, void *data)
3408	{
3409	struct clk_core *c;
3410	bool first_node = true;
3411	struct hlist_head **lists = s->private;
3412	int ret;
3413
3414	ret = clk_pm_runtime_get_all();
3415	if (ret)
3416	return ret;
3417
3418	seq_putc(m: s, c: '{');
3419
3420	clk_prepare_lock();
3421
3422	for (; *lists; lists++) {
3423	hlist_for_each_entry(c, *lists, child_node) {
3424	if (!first_node)
3425	seq_putc(m: s, c: ',');
3426	first_node = false;
3427	clk_dump_subtree(s, c, level: 0);
3428	}
3429	}
3430
3431	clk_prepare_unlock();
3432	clk_pm_runtime_put_all();
3433
3434	seq_puts(m: s, s: "}\n");
3435	return 0;
3436	}
3437	DEFINE_SHOW_ATTRIBUTE(clk_dump);
3438
3439	#undef CLOCK_ALLOW_WRITE_DEBUGFS
3440	#ifdef CLOCK_ALLOW_WRITE_DEBUGFS
3441	/*
3442	* This can be dangerous, therefore don't provide any real compile time
3443	* configuration option for this feature.
3444	* People who want to use this will need to modify the source code directly.
3445	*/
3446	static int clk_rate_set(void *data, u64 val)
3447	{
3448	struct clk_core *core = data;
3449	int ret;
3450
3451	clk_prepare_lock();
3452	ret = clk_core_set_rate_nolock(core, val);
3453	clk_prepare_unlock();
3454
3455	return ret;
3456	}
3457
3458	#define clk_rate_mode 0644
3459
3460	static int clk_phase_set(void *data, u64 val)
3461	{
3462	struct clk_core *core = data;
3463	int degrees = do_div(val, 360);
3464	int ret;
3465
3466	clk_prepare_lock();
3467	ret = clk_core_set_phase_nolock(core, degrees);
3468	clk_prepare_unlock();
3469
3470	return ret;
3471	}
3472
3473	#define clk_phase_mode 0644
3474
3475	static int clk_prepare_enable_set(void *data, u64 val)
3476	{
3477	struct clk_core *core = data;
3478	int ret = 0;
3479
3480	if (val)
3481	ret = clk_prepare_enable(core->hw->clk);
3482	else
3483	clk_disable_unprepare(core->hw->clk);
3484
3485	return ret;
3486	}
3487
3488	static int clk_prepare_enable_get(void *data, u64 *val)
3489	{
3490	struct clk_core *core = data;
3491
3492	*val = core->enable_count && core->prepare_count;
3493	return 0;
3494	}
3495
3496	DEFINE_DEBUGFS_ATTRIBUTE(clk_prepare_enable_fops, clk_prepare_enable_get,
3497	clk_prepare_enable_set, "%llu\n");
3498
3499	#else
3500	#define clk_rate_set NULL
3501	#define clk_rate_mode 0444
3502
3503	#define clk_phase_set NULL
3504	#define clk_phase_mode 0644
3505	#endif
3506
3507	static int clk_rate_get(void *data, u64 *val)
3508	{
3509	struct clk_core *core = data;
3510
3511	clk_prepare_lock();
3512	*val = clk_core_get_rate_recalc(core);
3513	clk_prepare_unlock();
3514
3515	return 0;
3516	}
3517
3518	DEFINE_DEBUGFS_ATTRIBUTE(clk_rate_fops, clk_rate_get, clk_rate_set, "%llu\n");
3519
3520	static int clk_phase_get(void *data, u64 *val)
3521	{
3522	struct clk_core *core = data;
3523
3524	*val = core->phase;
3525	return 0;
3526	}
3527
3528	DEFINE_DEBUGFS_ATTRIBUTE(clk_phase_fops, clk_phase_get, clk_phase_set, "%llu\n");
3529
3530	static const struct {
3531	unsigned long flag;
3532	const char *name;
3533	} clk_flags[] = {
3534	#define ENTRY(f) { f, #f }
3535	ENTRY(CLK_SET_RATE_GATE),
3536	ENTRY(CLK_SET_PARENT_GATE),
3537	ENTRY(CLK_SET_RATE_PARENT),
3538	ENTRY(CLK_IGNORE_UNUSED),
3539	ENTRY(CLK_GET_RATE_NOCACHE),
3540	ENTRY(CLK_SET_RATE_NO_REPARENT),
3541	ENTRY(CLK_GET_ACCURACY_NOCACHE),
3542	ENTRY(CLK_RECALC_NEW_RATES),
3543	ENTRY(CLK_SET_RATE_UNGATE),
3544	ENTRY(CLK_IS_CRITICAL),
3545	ENTRY(CLK_OPS_PARENT_ENABLE),
3546	ENTRY(CLK_DUTY_CYCLE_PARENT),
3547	#undef ENTRY
3548	};
3549
3550	static int clk_flags_show(struct seq_file *s, void *data)
3551	{
3552	struct clk_core *core = s->private;
3553	unsigned long flags = core->flags;
3554	unsigned int i;
3555
3556	for (i = 0; flags && i < ARRAY_SIZE(clk_flags); i++) {
3557	if (flags & clk_flags[i].flag) {
3558	seq_printf(m: s, fmt: "%s\n", clk_flags[i].name);
3559	flags &= ~clk_flags[i].flag;
3560	}
3561	}
3562	if (flags) {
3563	/* Unknown flags */
3564	seq_printf(m: s, fmt: "0x%lx\n", flags);
3565	}
3566
3567	return 0;
3568	}
3569	DEFINE_SHOW_ATTRIBUTE(clk_flags);
3570
3571	static void possible_parent_show(struct seq_file *s, struct clk_core *core,
3572	unsigned int i, char terminator)
3573	{
3574	struct clk_core *parent;
3575	const char *name = NULL;
3576
3577	/*
3578	* Go through the following options to fetch a parent's name.
3579	*
3580	* 1. Fetch the registered parent clock and use its name
3581	* 2. Use the global (fallback) name if specified
3582	* 3. Use the local fw_name if provided
3583	* 4. Fetch parent clock's clock-output-name if DT index was set
3584	*
3585	* This may still fail in some cases, such as when the parent is
3586	* specified directly via a struct clk_hw pointer, but it isn't
3587	* registered (yet).
3588	*/
3589	parent = clk_core_get_parent_by_index(core, index: i);
3590	if (parent) {
3591	seq_puts(m: s, s: parent->name);
3592	} else if (core->parents[i].name) {
3593	seq_puts(m: s, s: core->parents[i].name);
3594	} else if (core->parents[i].fw_name) {
3595	seq_printf(m: s, fmt: "<%s>(fw)", core->parents[i].fw_name);
3596	} else {
3597	if (core->parents[i].index >= 0)
3598	name = of_clk_get_parent_name(np: core->of_node, index: core->parents[i].index);
3599	if (!name)
3600	name = "(missing)";
3601
3602	seq_puts(m: s, s: name);
3603	}
3604
3605	seq_putc(m: s, c: terminator);
3606	}
3607
3608	static int possible_parents_show(struct seq_file *s, void *data)
3609	{
3610	struct clk_core *core = s->private;
3611	int i;
3612
3613	for (i = 0; i < core->num_parents - 1; i++)
3614	possible_parent_show(s, core, i, terminator: ' ');
3615
3616	possible_parent_show(s, core, i, terminator: '\n');
3617
3618	return 0;
3619	}
3620	DEFINE_SHOW_ATTRIBUTE(possible_parents);
3621
3622	static int current_parent_show(struct seq_file *s, void *data)
3623	{
3624	struct clk_core *core = s->private;
3625
3626	if (core->parent)
3627	seq_printf(m: s, fmt: "%s\n", core->parent->name);
3628
3629	return 0;
3630	}
3631	DEFINE_SHOW_ATTRIBUTE(current_parent);
3632
3633	#ifdef CLOCK_ALLOW_WRITE_DEBUGFS
3634	static ssize_t current_parent_write(struct file *file, const char __user *ubuf,
3635	size_t count, loff_t *ppos)
3636	{
3637	struct seq_file *s = file->private_data;
3638	struct clk_core *core = s->private;
3639	struct clk_core *parent;
3640	u8 idx;
3641	int err;
3642
3643	err = kstrtou8_from_user(ubuf, count, 0, &idx);
3644	if (err < 0)
3645	return err;
3646
3647	parent = clk_core_get_parent_by_index(core, idx);
3648	if (!parent)
3649	return -ENOENT;
3650
3651	clk_prepare_lock();
3652	err = clk_core_set_parent_nolock(core, parent);
3653	clk_prepare_unlock();
3654	if (err)
3655	return err;
3656
3657	return count;
3658	}
3659
3660	static const struct file_operations current_parent_rw_fops = {
3661	.open = current_parent_open,
3662	.write = current_parent_write,
3663	.read = seq_read,
3664	.llseek = seq_lseek,
3665	.release = single_release,
3666	};
3667	#endif
3668
3669	static int clk_duty_cycle_show(struct seq_file *s, void *data)
3670	{
3671	struct clk_core *core = s->private;
3672	struct clk_duty *duty = &core->duty;
3673
3674	seq_printf(m: s, fmt: "%u/%u\n", duty->num, duty->den);
3675
3676	return 0;
3677	}
3678	DEFINE_SHOW_ATTRIBUTE(clk_duty_cycle);
3679
3680	static int clk_min_rate_show(struct seq_file *s, void *data)
3681	{
3682	struct clk_core *core = s->private;
3683	unsigned long min_rate, max_rate;
3684
3685	clk_prepare_lock();
3686	clk_core_get_boundaries(core, min_rate: &min_rate, max_rate: &max_rate);
3687	clk_prepare_unlock();
3688	seq_printf(m: s, fmt: "%lu\n", min_rate);
3689
3690	return 0;
3691	}
3692	DEFINE_SHOW_ATTRIBUTE(clk_min_rate);
3693
3694	static int clk_max_rate_show(struct seq_file *s, void *data)
3695	{
3696	struct clk_core *core = s->private;
3697	unsigned long min_rate, max_rate;
3698
3699	clk_prepare_lock();
3700	clk_core_get_boundaries(core, min_rate: &min_rate, max_rate: &max_rate);
3701	clk_prepare_unlock();
3702	seq_printf(m: s, fmt: "%lu\n", max_rate);
3703
3704	return 0;
3705	}
3706	DEFINE_SHOW_ATTRIBUTE(clk_max_rate);
3707
3708	static void clk_debug_create_one(struct clk_core *core, struct dentry *pdentry)
3709	{
3710	struct dentry *root;
3711
3712	if (!core || !pdentry)
3713	return;
3714
3715	root = debugfs_create_dir(name: core->name, parent: pdentry);
3716	core->dentry = root;
3717
3718	debugfs_create_file("clk_rate", clk_rate_mode, root, core,
3719	&clk_rate_fops);
3720	debugfs_create_file("clk_min_rate", 0444, root, core, &clk_min_rate_fops);
3721	debugfs_create_file("clk_max_rate", 0444, root, core, &clk_max_rate_fops);
3722	debugfs_create_ulong(name: "clk_accuracy", mode: 0444, parent: root, value: &core->accuracy);
3723	debugfs_create_file("clk_phase", clk_phase_mode, root, core,
3724	&clk_phase_fops);
3725	debugfs_create_file("clk_flags", 0444, root, core, &clk_flags_fops);
3726	debugfs_create_u32(name: "clk_prepare_count", mode: 0444, parent: root, value: &core->prepare_count);
3727	debugfs_create_u32(name: "clk_enable_count", mode: 0444, parent: root, value: &core->enable_count);
3728	debugfs_create_u32(name: "clk_protect_count", mode: 0444, parent: root, value: &core->protect_count);
3729	debugfs_create_u32(name: "clk_notifier_count", mode: 0444, parent: root, value: &core->notifier_count);
3730	debugfs_create_file("clk_duty_cycle", 0444, root, core,
3731	&clk_duty_cycle_fops);
3732	#ifdef CLOCK_ALLOW_WRITE_DEBUGFS
3733	debugfs_create_file("clk_prepare_enable", 0644, root, core,
3734	&clk_prepare_enable_fops);
3735
3736	if (core->num_parents > 1)
3737	debugfs_create_file("clk_parent", 0644, root, core,
3738	&current_parent_rw_fops);
3739	else
3740	#endif
3741	if (core->num_parents > 0)
3742	debugfs_create_file("clk_parent", 0444, root, core,
3743	&current_parent_fops);
3744
3745	if (core->num_parents > 1)
3746	debugfs_create_file("clk_possible_parents", 0444, root, core,
3747	&possible_parents_fops);
3748
3749	if (core->ops->debug_init)
3750	core->ops->debug_init(core->hw, core->dentry);
3751	}
3752
3753	/**
3754	* clk_debug_register - add a clk node to the debugfs clk directory
3755	* @core: the clk being added to the debugfs clk directory
3756	*
3757	* Dynamically adds a clk to the debugfs clk directory if debugfs has been
3758	* initialized. Otherwise it bails out early since the debugfs clk directory
3759	* will be created lazily by clk_debug_init as part of a late_initcall.
3760	*/
3761	static void clk_debug_register(struct clk_core *core)
3762	{
3763	mutex_lock(&clk_debug_lock);
3764	hlist_add_head(n: &core->debug_node, h: &clk_debug_list);
3765	if (inited)
3766	clk_debug_create_one(core, pdentry: rootdir);
3767	mutex_unlock(lock: &clk_debug_lock);
3768	}
3769
3770	/**
3771	* clk_debug_unregister - remove a clk node from the debugfs clk directory
3772	* @core: the clk being removed from the debugfs clk directory
3773	*
3774	* Dynamically removes a clk and all its child nodes from the
3775	* debugfs clk directory if clk->dentry points to debugfs created by
3776	* clk_debug_register in __clk_core_init.
3777	*/
3778	static void clk_debug_unregister(struct clk_core *core)
3779	{
3780	mutex_lock(&clk_debug_lock);
3781	hlist_del_init(n: &core->debug_node);
3782	debugfs_remove_recursive(dentry: core->dentry);
3783	core->dentry = NULL;
3784	mutex_unlock(lock: &clk_debug_lock);
3785	}
3786
3787	/**
3788	* clk_debug_init - lazily populate the debugfs clk directory
3789	*
3790	* clks are often initialized very early during boot before memory can be
3791	* dynamically allocated and well before debugfs is setup. This function
3792	* populates the debugfs clk directory once at boot-time when we know that
3793	* debugfs is setup. It should only be called once at boot-time, all other clks
3794	* added dynamically will be done so with clk_debug_register.
3795	*/
3796	static int __init clk_debug_init(void)
3797	{
3798	struct clk_core *core;
3799
3800	#ifdef CLOCK_ALLOW_WRITE_DEBUGFS
3801	pr_warn("\n");
3802	pr_warn("********************************************************************\n");
3803	pr_warn("** NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE **\n");
3804	pr_warn("** **\n");
3805	pr_warn("** WRITEABLE clk DebugFS SUPPORT HAS BEEN ENABLED IN THIS KERNEL **\n");
3806	pr_warn("** **\n");
3807	pr_warn("** This means that this kernel is built to expose clk operations **\n");
3808	pr_warn("** such as parent or rate setting, enabling, disabling, etc. **\n");
3809	pr_warn("** to userspace, which may compromise security on your system. **\n");
3810	pr_warn("** **\n");
3811	pr_warn("** If you see this message and you are not debugging the **\n");
3812	pr_warn("** kernel, report this immediately to your vendor! **\n");
3813	pr_warn("** **\n");
3814	pr_warn("** NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE **\n");
3815	pr_warn("********************************************************************\n");
3816	#endif
3817
3818	rootdir = debugfs_create_dir(name: "clk", NULL);
3819
3820	debugfs_create_file("clk_summary", 0444, rootdir, &all_lists,
3821	&clk_summary_fops);
3822	debugfs_create_file("clk_dump", 0444, rootdir, &all_lists,
3823	&clk_dump_fops);
3824	debugfs_create_file("clk_orphan_summary", 0444, rootdir, &orphan_list,
3825	&clk_summary_fops);
3826	debugfs_create_file("clk_orphan_dump", 0444, rootdir, &orphan_list,
3827	&clk_dump_fops);
3828
3829	mutex_lock(&clk_debug_lock);
3830	hlist_for_each_entry(core, &clk_debug_list, debug_node)
3831	clk_debug_create_one(core, pdentry: rootdir);
3832
3833	inited = 1;
3834	mutex_unlock(lock: &clk_debug_lock);
3835
3836	return 0;
3837	}
3838	late_initcall(clk_debug_init);
3839	#else
3840	static inline void clk_debug_register(struct clk_core *core) { }
3841	static inline void clk_debug_unregister(struct clk_core *core)
3842	{
3843	}
3844	#endif
3845
3846	static void clk_core_reparent_orphans_nolock(void)
3847	{
3848	struct clk_core *orphan;
3849	struct hlist_node *tmp2;
3850
3851	/*
3852	* walk the list of orphan clocks and reparent any that newly finds a
3853	* parent.
3854	*/
3855	hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) {
3856	struct clk_core *parent = __clk_init_parent(core: orphan);
3857
3858	/*
3859	* We need to use __clk_set_parent_before() and _after() to
3860	* properly migrate any prepare/enable count of the orphan
3861	* clock. This is important for CLK_IS_CRITICAL clocks, which
3862	* are enabled during init but might not have a parent yet.
3863	*/
3864	if (parent) {
3865	/* update the clk tree topology */
3866	__clk_set_parent_before(core: orphan, parent);
3867	__clk_set_parent_after(core: orphan, parent, NULL);
3868	__clk_recalc_accuracies(core: orphan);
3869	__clk_recalc_rates(core: orphan, update_req: true, msg: 0);
3870
3871	/*
3872	* __clk_init_parent() will set the initial req_rate to
3873	* 0 if the clock doesn't have clk_ops::recalc_rate and
3874	* is an orphan when it's registered.
3875	*
3876	* 'req_rate' is used by clk_set_rate_range() and
3877	* clk_put() to trigger a clk_set_rate() call whenever
3878	* the boundaries are modified. Let's make sure
3879	* 'req_rate' is set to something non-zero so that
3880	* clk_set_rate_range() doesn't drop the frequency.
3881	*/
3882	orphan->req_rate = orphan->rate;
3883	}
3884	}
3885	}
3886
3887	/**
3888	* __clk_core_init - initialize the data structures in a struct clk_core
3889	* @core: clk_core being initialized
3890	*
3891	* Initializes the lists in struct clk_core, queries the hardware for the
3892	* parent and rate and sets them both.
3893	*/
3894	static int __clk_core_init(struct clk_core *core)
3895	{
3896	int ret;
3897	struct clk_core *parent;
3898	unsigned long rate;
3899	int phase;
3900
3901	clk_prepare_lock();
3902
3903	/*
3904	* Set hw->core after grabbing the prepare_lock to synchronize with
3905	* callers of clk_core_fill_parent_index() where we treat hw->core
3906	* being NULL as the clk not being registered yet. This is crucial so
3907	* that clks aren't parented until their parent is fully registered.
3908	*/
3909	core->hw->core = core;
3910
3911	ret = clk_pm_runtime_get(core);
3912	if (ret)
3913	goto unlock;
3914
3915	/* check to see if a clock with this name is already registered */
3916	if (clk_core_lookup(name: core->name)) {
3917	pr_debug("%s: clk %s already initialized\n",
3918	__func__, core->name);
3919	ret = -EEXIST;
3920	goto out;
3921	}
3922
3923	/* check that clk_ops are sane. See Documentation/driver-api/clk.rst */
3924	if (core->ops->set_rate &&
3925	!((core->ops->round_rate || core->ops->determine_rate) &&
3926	core->ops->recalc_rate)) {
3927	pr_err("%s: %s must implement .round_rate or .determine_rate in addition to .recalc_rate\n",
3928	__func__, core->name);
3929	ret = -EINVAL;
3930	goto out;
3931	}
3932
3933	if (core->ops->set_parent && !core->ops->get_parent) {
3934	pr_err("%s: %s must implement .get_parent & .set_parent\n",
3935	__func__, core->name);
3936	ret = -EINVAL;
3937	goto out;
3938	}
3939
3940	if (core->ops->set_parent && !core->ops->determine_rate) {
3941	pr_err("%s: %s must implement .set_parent & .determine_rate\n",
3942	__func__, core->name);
3943	ret = -EINVAL;
3944	goto out;
3945	}
3946
3947	if (core->num_parents > 1 && !core->ops->get_parent) {
3948	pr_err("%s: %s must implement .get_parent as it has multi parents\n",
3949	__func__, core->name);
3950	ret = -EINVAL;
3951	goto out;
3952	}
3953
3954	if (core->ops->set_rate_and_parent &&
3955	!(core->ops->set_parent && core->ops->set_rate)) {
3956	pr_err("%s: %s must implement .set_parent & .set_rate\n",
3957	__func__, core->name);
3958	ret = -EINVAL;
3959	goto out;
3960	}
3961
3962	/*
3963	* optional platform-specific magic
3964	*
3965	* The .init callback is not used by any of the basic clock types, but
3966	* exists for weird hardware that must perform initialization magic for
3967	* CCF to get an accurate view of clock for any other callbacks. It may
3968	* also be used needs to perform dynamic allocations. Such allocation
3969	* must be freed in the terminate() callback.
3970	* This callback shall not be used to initialize the parameters state,
3971	* such as rate, parent, etc ...
3972	*
3973	* If it exist, this callback should called before any other callback of
3974	* the clock
3975	*/
3976	if (core->ops->init) {
3977	ret = core->ops->init(core->hw);
3978	if (ret)
3979	goto out;
3980	}
3981
3982	parent = core->parent = __clk_init_parent(core);
3983
3984	/*
3985	* Populate core->parent if parent has already been clk_core_init'd. If
3986	* parent has not yet been clk_core_init'd then place clk in the orphan
3987	* list. If clk doesn't have any parents then place it in the root
3988	* clk list.
3989	*
3990	* Every time a new clk is clk_init'd then we walk the list of orphan
3991	* clocks and re-parent any that are children of the clock currently
3992	* being clk_init'd.
3993	*/
3994	if (parent) {
3995	hlist_add_head(n: &core->child_node, h: &parent->children);
3996	core->orphan = parent->orphan;
3997	} else if (!core->num_parents) {
3998	hlist_add_head(n: &core->child_node, h: &clk_root_list);
3999	core->orphan = false;
4000	} else {
4001	hlist_add_head(n: &core->child_node, h: &clk_orphan_list);
4002	core->orphan = true;
4003	}
4004
4005	/*
4006	* Set clk's accuracy. The preferred method is to use
4007	* .recalc_accuracy. For simple clocks and lazy developers the default
4008	* fallback is to use the parent's accuracy. If a clock doesn't have a
4009	* parent (or is orphaned) then accuracy is set to zero (perfect
4010	* clock).
4011	*/
4012	if (core->ops->recalc_accuracy)
4013	core->accuracy = core->ops->recalc_accuracy(core->hw,
4014	clk_core_get_accuracy_no_lock(core: parent));
4015	else if (parent)
4016	core->accuracy = parent->accuracy;
4017	else
4018	core->accuracy = 0;
4019
4020	/*
4021	* Set clk's phase by clk_core_get_phase() caching the phase.
4022	* Since a phase is by definition relative to its parent, just
4023	* query the current clock phase, or just assume it's in phase.
4024	*/
4025	phase = clk_core_get_phase(core);
4026	if (phase < 0) {
4027	ret = phase;
4028	pr_warn("%s: Failed to get phase for clk '%s'\n", __func__,
4029	core->name);
4030	goto out;
4031	}
4032
4033	/*
4034	* Set clk's duty cycle.
4035	*/
4036	clk_core_update_duty_cycle_nolock(core);
4037
4038	/*
4039	* Set clk's rate. The preferred method is to use .recalc_rate. For
4040	* simple clocks and lazy developers the default fallback is to use the
4041	* parent's rate. If a clock doesn't have a parent (or is orphaned)
4042	* then rate is set to zero.
4043	*/
4044	if (core->ops->recalc_rate)
4045	rate = core->ops->recalc_rate(core->hw,
4046	clk_core_get_rate_nolock(core: parent));
4047	else if (parent)
4048	rate = parent->rate;
4049	else
4050	rate = 0;
4051	core->rate = core->req_rate = rate;
4052
4053	/*
4054	* Enable CLK_IS_CRITICAL clocks so newly added critical clocks
4055	* don't get accidentally disabled when walking the orphan tree and
4056	* reparenting clocks
4057	*/
4058	if (core->flags & CLK_IS_CRITICAL) {
4059	ret = clk_core_prepare(core);
4060	if (ret) {
4061	pr_warn("%s: critical clk '%s' failed to prepare\n",
4062	__func__, core->name);
4063	goto out;
4064	}
4065
4066	ret = clk_core_enable_lock(core);
4067	if (ret) {
4068	pr_warn("%s: critical clk '%s' failed to enable\n",
4069	__func__, core->name);
4070	clk_core_unprepare(core);
4071	goto out;
4072	}
4073	}
4074
4075	clk_core_reparent_orphans_nolock();
4076	out:
4077	clk_pm_runtime_put(core);
4078	unlock:
4079	if (ret) {
4080	hlist_del_init(n: &core->child_node);
4081	core->hw->core = NULL;
4082	}
4083
4084	clk_prepare_unlock();
4085
4086	if (!ret)
4087	clk_debug_register(core);
4088
4089	return ret;
4090	}
4091
4092	/**
4093	* clk_core_link_consumer - Add a clk consumer to the list of consumers in a clk_core
4094	* @core: clk to add consumer to
4095	* @clk: consumer to link to a clk
4096	*/
4097	static void clk_core_link_consumer(struct clk_core *core, struct clk *clk)
4098	{
4099	clk_prepare_lock();
4100	hlist_add_head(n: &clk->clks_node, h: &core->clks);
4101	clk_prepare_unlock();
4102	}
4103
4104	/**
4105	* clk_core_unlink_consumer - Remove a clk consumer from the list of consumers in a clk_core
4106	* @clk: consumer to unlink
4107	*/
4108	static void clk_core_unlink_consumer(struct clk *clk)
4109	{
4110	lockdep_assert_held(&prepare_lock);
4111	hlist_del(n: &clk->clks_node);
4112	}
4113
4114	/**
4115	* alloc_clk - Allocate a clk consumer, but leave it unlinked to the clk_core
4116	* @core: clk to allocate a consumer for
4117	* @dev_id: string describing device name
4118	* @con_id: connection ID string on device
4119	*
4120	* Returns: clk consumer left unlinked from the consumer list
4121	*/
4122	static struct clk *alloc_clk(struct clk_core *core, const char *dev_id,
4123	const char *con_id)
4124	{
4125	struct clk *clk;
4126
4127	clk = kzalloc(sizeof(*clk), GFP_KERNEL);
4128	if (!clk)
4129	return ERR_PTR(error: -ENOMEM);
4130
4131	clk->core = core;
4132	clk->dev_id = dev_id;
4133	clk->con_id = kstrdup_const(s: con_id, GFP_KERNEL);
4134	clk->max_rate = ULONG_MAX;
4135
4136	return clk;
4137	}
4138
4139	/**
4140	* free_clk - Free a clk consumer
4141	* @clk: clk consumer to free
4142	*
4143	* Note, this assumes the clk has been unlinked from the clk_core consumer
4144	* list.
4145	*/
4146	static void free_clk(struct clk *clk)
4147	{
4148	kfree_const(x: clk->con_id);
4149	kfree(objp: clk);
4150	}
4151
4152	/**
4153	* clk_hw_create_clk: Allocate and link a clk consumer to a clk_core given
4154	* a clk_hw
4155	* @dev: clk consumer device
4156	* @hw: clk_hw associated with the clk being consumed
4157	* @dev_id: string describing device name
4158	* @con_id: connection ID string on device
4159	*
4160	* This is the main function used to create a clk pointer for use by clk
4161	* consumers. It connects a consumer to the clk_core and clk_hw structures
4162	* used by the framework and clk provider respectively.
4163	*/
4164	struct clk *clk_hw_create_clk(struct device *dev, struct clk_hw *hw,
4165	const char *dev_id, const char *con_id)
4166	{
4167	struct clk *clk;
4168	struct clk_core *core;
4169
4170	/* This is to allow this function to be chained to others */
4171	if (IS_ERR_OR_NULL(ptr: hw))
4172	return ERR_CAST(ptr: hw);
4173
4174	core = hw->core;
4175	clk = alloc_clk(core, dev_id, con_id);
4176	if (IS_ERR(ptr: clk))
4177	return clk;
4178	clk->dev = dev;
4179
4180	if (!try_module_get(module: core->owner)) {
4181	free_clk(clk);
4182	return ERR_PTR(error: -ENOENT);
4183	}
4184
4185	kref_get(kref: &core->ref);
4186	clk_core_link_consumer(core, clk);
4187
4188	return clk;
4189	}
4190
4191	/**
4192	* clk_hw_get_clk - get clk consumer given an clk_hw
4193	* @hw: clk_hw associated with the clk being consumed
4194	* @con_id: connection ID string on device
4195	*
4196	* Returns: new clk consumer
4197	* This is the function to be used by providers which need
4198	* to get a consumer clk and act on the clock element
4199	* Calls to this function must be balanced with calls clk_put()
4200	*/
4201	struct clk *clk_hw_get_clk(struct clk_hw *hw, const char *con_id)
4202	{
4203	struct device *dev = hw->core->dev;
4204	const char *name = dev ? dev_name(dev) : NULL;
4205
4206	return clk_hw_create_clk(dev, hw, dev_id: name, con_id);
4207	}
4208	EXPORT_SYMBOL(clk_hw_get_clk);
4209
4210	static int clk_cpy_name(const char **dst_p, const char *src, bool must_exist)
4211	{
4212	const char *dst;
4213
4214	if (!src) {
4215	if (must_exist)
4216	return -EINVAL;
4217	return 0;
4218	}
4219
4220	*dst_p = dst = kstrdup_const(s: src, GFP_KERNEL);
4221	if (!dst)
4222	return -ENOMEM;
4223
4224	return 0;
4225	}
4226
4227	static int clk_core_populate_parent_map(struct clk_core *core,
4228	const struct clk_init_data *init)
4229	{
4230	u8 num_parents = init->num_parents;
4231	const char * const *parent_names = init->parent_names;
4232	const struct clk_hw **parent_hws = init->parent_hws;
4233	const struct clk_parent_data *parent_data = init->parent_data;
4234	int i, ret = 0;
4235	struct clk_parent_map *parents, *parent;
4236
4237	if (!num_parents)
4238	return 0;
4239
4240	/*
4241	* Avoid unnecessary string look-ups of clk_core's possible parents by
4242	* having a cache of names/clk_hw pointers to clk_core pointers.
4243	*/
4244	parents = kcalloc(num_parents, sizeof(*parents), GFP_KERNEL);
4245	core->parents = parents;
4246	if (!parents)
4247	return -ENOMEM;
4248
4249	/* Copy everything over because it might be __initdata */
4250	for (i = 0, parent = parents; i < num_parents; i++, parent++) {
4251	parent->index = -1;
4252	if (parent_names) {
4253	/* throw a WARN if any entries are NULL */
4254	WARN(!parent_names[i],
4255	"%s: invalid NULL in %s's .parent_names\n",
4256	__func__, core->name);
4257	ret = clk_cpy_name(dst_p: &parent->name, src: parent_names[i],
4258	must_exist: true);
4259	} else if (parent_data) {
4260	parent->hw = parent_data[i].hw;
4261	parent->index = parent_data[i].index;
4262	ret = clk_cpy_name(dst_p: &parent->fw_name,
4263	src: parent_data[i].fw_name, must_exist: false);
4264	if (!ret)
4265	ret = clk_cpy_name(dst_p: &parent->name,
4266	src: parent_data[i].name,
4267	must_exist: false);
4268	} else if (parent_hws) {
4269	parent->hw = parent_hws[i];
4270	} else {
4271	ret = -EINVAL;
4272	WARN(1, "Must specify parents if num_parents > 0\n");
4273	}
4274
4275	if (ret) {
4276	do {
4277	kfree_const(x: parents[i].name);
4278	kfree_const(x: parents[i].fw_name);
4279	} while (--i >= 0);
4280	kfree(objp: parents);
4281
4282	return ret;
4283	}
4284	}
4285
4286	return 0;
4287	}
4288
4289	static void clk_core_free_parent_map(struct clk_core *core)
4290	{
4291	int i = core->num_parents;
4292
4293	if (!core->num_parents)
4294	return;
4295
4296	while (--i >= 0) {
4297	kfree_const(x: core->parents[i].name);
4298	kfree_const(x: core->parents[i].fw_name);
4299	}
4300
4301	kfree(objp: core->parents);
4302	}
4303
4304	/* Free memory allocated for a struct clk_core */
4305	static void __clk_release(struct kref *ref)
4306	{
4307	struct clk_core *core = container_of(ref, struct clk_core, ref);
4308
4309	if (core->rpm_enabled) {
4310	mutex_lock(&clk_rpm_list_lock);
4311	hlist_del(n: &core->rpm_node);
4312	mutex_unlock(lock: &clk_rpm_list_lock);
4313	}
4314
4315	clk_core_free_parent_map(core);
4316	kfree_const(x: core->name);
4317	kfree(objp: core);
4318	}
4319
4320	static struct clk *
4321	__clk_register(struct device *dev, struct device_node *np, struct clk_hw *hw)
4322	{
4323	int ret;
4324	struct clk_core *core;
4325	const struct clk_init_data *init = hw->init;
4326
4327	/*
4328	* The init data is not supposed to be used outside of registration path.
4329	* Set it to NULL so that provider drivers can't use it either and so that
4330	* we catch use of hw->init early on in the core.
4331	*/
4332	hw->init = NULL;
4333
4334	core = kzalloc(sizeof(*core), GFP_KERNEL);
4335	if (!core) {
4336	ret = -ENOMEM;
4337	goto fail_out;
4338	}
4339
4340	kref_init(kref: &core->ref);
4341
4342	core->name = kstrdup_const(s: init->name, GFP_KERNEL);
4343	if (!core->name) {
4344	ret = -ENOMEM;
4345	goto fail_name;
4346	}
4347
4348	if (WARN_ON(!init->ops)) {
4349	ret = -EINVAL;
4350	goto fail_ops;
4351	}
4352	core->ops = init->ops;
4353
4354	core->dev = dev;
4355	clk_pm_runtime_init(core);
4356	core->of_node = np;
4357	if (dev && dev->driver)
4358	core->owner = dev->driver->owner;
4359	core->hw = hw;
4360	core->flags = init->flags;
4361	core->num_parents = init->num_parents;
4362	core->min_rate = 0;
4363	core->max_rate = ULONG_MAX;
4364
4365	ret = clk_core_populate_parent_map(core, init);
4366	if (ret)
4367	goto fail_parents;
4368
4369	INIT_HLIST_HEAD(&core->clks);
4370
4371	/*
4372	* Don't call clk_hw_create_clk() here because that would pin the
4373	* provider module to itself and prevent it from ever being removed.
4374	*/
4375	hw->clk = alloc_clk(core, NULL, NULL);
4376	if (IS_ERR(ptr: hw->clk)) {
4377	ret = PTR_ERR(ptr: hw->clk);
4378	goto fail_create_clk;
4379	}
4380
4381	clk_core_link_consumer(core, clk: hw->clk);
4382
4383	ret = __clk_core_init(core);
4384	if (!ret)
4385	return hw->clk;
4386
4387	clk_prepare_lock();
4388	clk_core_unlink_consumer(clk: hw->clk);
4389	clk_prepare_unlock();
4390
4391	free_clk(clk: hw->clk);
4392	hw->clk = NULL;
4393
4394	fail_create_clk:
4395	fail_parents:
4396	fail_ops:
4397	fail_name:
4398	kref_put(kref: &core->ref, release: __clk_release);
4399	fail_out:
4400	if (dev) {
4401	dev_err_probe(dev, err: ret, fmt: "failed to register clk '%s' (%pS)\n",
4402	init->name, hw);
4403	} else {
4404	pr_err("%pOF: error %pe: failed to register clk '%s' (%pS)\n",
4405	np, ERR_PTR(ret), init->name, hw);
4406	}
4407	return ERR_PTR(error: ret);
4408	}
4409
4410	/**
4411	* dev_or_parent_of_node() - Get device node of @dev or @dev's parent
4412	* @dev: Device to get device node of
4413	*
4414	* Return: device node pointer of @dev, or the device node pointer of
4415	* @dev->parent if dev doesn't have a device node, or NULL if neither
4416	* @dev or @dev->parent have a device node.
4417	*/
4418	static struct device_node *dev_or_parent_of_node(struct device *dev)
4419	{
4420	struct device_node *np;
4421
4422	if (!dev)
4423	return NULL;
4424
4425	np = dev_of_node(dev);
4426	if (!np)
4427	np = dev_of_node(dev: dev->parent);
4428
4429	return np;
4430	}
4431
4432	/**
4433	* clk_register - allocate a new clock, register it and return an opaque cookie
4434	* @dev: device that is registering this clock
4435	* @hw: link to hardware-specific clock data
4436	*
4437	* clk_register is the *deprecated* interface for populating the clock tree with
4438	* new clock nodes. Use clk_hw_register() instead.
4439	*
4440	* Returns: a pointer to the newly allocated struct clk which
4441	* cannot be dereferenced by driver code but may be used in conjunction with the
4442	* rest of the clock API. In the event of an error clk_register will return an
4443	* error code; drivers must test for an error code after calling clk_register.
4444	*/
4445	struct clk *clk_register(struct device *dev, struct clk_hw *hw)
4446	{
4447	return __clk_register(dev, np: dev_or_parent_of_node(dev), hw);
4448	}
4449	EXPORT_SYMBOL_GPL(clk_register);
4450
4451	/**
4452	* clk_hw_register - register a clk_hw and return an error code
4453	* @dev: device that is registering this clock
4454	* @hw: link to hardware-specific clock data
4455	*
4456	* clk_hw_register is the primary interface for populating the clock tree with
4457	* new clock nodes. It returns an integer equal to zero indicating success or
4458	* less than zero indicating failure. Drivers must test for an error code after
4459	* calling clk_hw_register().
4460	*/
4461	int clk_hw_register(struct device *dev, struct clk_hw *hw)
4462	{
4463	return PTR_ERR_OR_ZERO(ptr: __clk_register(dev, np: dev_or_parent_of_node(dev),
4464	hw));
4465	}
4466	EXPORT_SYMBOL_GPL(clk_hw_register);
4467
4468	/*
4469	* of_clk_hw_register - register a clk_hw and return an error code
4470	* @node: device_node of device that is registering this clock
4471	* @hw: link to hardware-specific clock data
4472	*
4473	* of_clk_hw_register() is the primary interface for populating the clock tree
4474	* with new clock nodes when a struct device is not available, but a struct
4475	* device_node is. It returns an integer equal to zero indicating success or
4476	* less than zero indicating failure. Drivers must test for an error code after
4477	* calling of_clk_hw_register().
4478	*/
4479	int of_clk_hw_register(struct device_node *node, struct clk_hw *hw)
4480	{
4481	return PTR_ERR_OR_ZERO(ptr: __clk_register(NULL, np: node, hw));
4482	}
4483	EXPORT_SYMBOL_GPL(of_clk_hw_register);
4484
4485	/*
4486	* Empty clk_ops for unregistered clocks. These are used temporarily
4487	* after clk_unregister() was called on a clock and until last clock
4488	* consumer calls clk_put() and the struct clk object is freed.
4489	*/
4490	static int clk_nodrv_prepare_enable(struct clk_hw *hw)
4491	{
4492	return -ENXIO;
4493	}
4494
4495	static void clk_nodrv_disable_unprepare(struct clk_hw *hw)
4496	{
4497	WARN_ON_ONCE(1);
4498	}
4499
4500	static int clk_nodrv_set_rate(struct clk_hw *hw, unsigned long rate,
4501	unsigned long parent_rate)
4502	{
4503	return -ENXIO;
4504	}
4505
4506	static int clk_nodrv_set_parent(struct clk_hw *hw, u8 index)
4507	{
4508	return -ENXIO;
4509	}
4510
4511	static int clk_nodrv_determine_rate(struct clk_hw *hw,
4512	struct clk_rate_request *req)
4513	{
4514	return -ENXIO;
4515	}
4516
4517	static const struct clk_ops clk_nodrv_ops = {
4518	.enable = clk_nodrv_prepare_enable,
4519	.disable = clk_nodrv_disable_unprepare,
4520	.prepare = clk_nodrv_prepare_enable,
4521	.unprepare = clk_nodrv_disable_unprepare,
4522	.determine_rate = clk_nodrv_determine_rate,
4523	.set_rate = clk_nodrv_set_rate,
4524	.set_parent = clk_nodrv_set_parent,
4525	};
4526
4527	static void clk_core_evict_parent_cache_subtree(struct clk_core *root,
4528	const struct clk_core *target)
4529	{
4530	int i;
4531	struct clk_core *child;
4532
4533	for (i = 0; i < root->num_parents; i++)
4534	if (root->parents[i].core == target)
4535	root->parents[i].core = NULL;
4536
4537	hlist_for_each_entry(child, &root->children, child_node)
4538	clk_core_evict_parent_cache_subtree(root: child, target);
4539	}
4540
4541	/* Remove this clk from all parent caches */
4542	static void clk_core_evict_parent_cache(struct clk_core *core)
4543	{
4544	const struct hlist_head **lists;
4545	struct clk_core *root;
4546
4547	lockdep_assert_held(&prepare_lock);
4548
4549	for (lists = all_lists; *lists; lists++)
4550	hlist_for_each_entry(root, *lists, child_node)
4551	clk_core_evict_parent_cache_subtree(root, target: core);
4552
4553	}
4554
4555	/**
4556	* clk_unregister - unregister a currently registered clock
4557	* @clk: clock to unregister
4558	*/
4559	void clk_unregister(struct clk *clk)
4560	{
4561	unsigned long flags;
4562	const struct clk_ops *ops;
4563
4564	if (!clk || WARN_ON_ONCE(IS_ERR(clk)))
4565	return;
4566
4567	clk_debug_unregister(core: clk->core);
4568
4569	clk_prepare_lock();
4570
4571	ops = clk->core->ops;
4572	if (ops == &clk_nodrv_ops) {
4573	pr_err("%s: unregistered clock: %s\n", __func__,
4574	clk->core->name);
4575	clk_prepare_unlock();
4576	return;
4577	}
4578	/*
4579	* Assign empty clock ops for consumers that might still hold
4580	* a reference to this clock.
4581	*/
4582	flags = clk_enable_lock();
4583	clk->core->ops = &clk_nodrv_ops;
4584	clk_enable_unlock(flags);
4585
4586	if (ops->terminate)
4587	ops->terminate(clk->core->hw);
4588
4589	if (!hlist_empty(h: &clk->core->children)) {
4590	struct clk_core *child;
4591	struct hlist_node *t;
4592
4593	/* Reparent all children to the orphan list. */
4594	hlist_for_each_entry_safe(child, t, &clk->core->children,
4595	child_node)
4596	clk_core_set_parent_nolock(core: child, NULL);
4597	}
4598
4599	clk_core_evict_parent_cache(core: clk->core);
4600
4601	hlist_del_init(n: &clk->core->child_node);
4602
4603	if (clk->core->prepare_count)
4604	pr_warn("%s: unregistering prepared clock: %s\n",
4605	__func__, clk->core->name);
4606
4607	if (clk->core->protect_count)
4608	pr_warn("%s: unregistering protected clock: %s\n",
4609	__func__, clk->core->name);
4610	clk_prepare_unlock();
4611
4612	kref_put(kref: &clk->core->ref, release: __clk_release);
4613	free_clk(clk);
4614	}
4615	EXPORT_SYMBOL_GPL(clk_unregister);
4616
4617	/**
4618	* clk_hw_unregister - unregister a currently registered clk_hw
4619	* @hw: hardware-specific clock data to unregister
4620	*/
4621	void clk_hw_unregister(struct clk_hw *hw)
4622	{
4623	clk_unregister(hw->clk);
4624	}
4625	EXPORT_SYMBOL_GPL(clk_hw_unregister);
4626
4627	static void devm_clk_unregister_cb(struct device *dev, void *res)
4628	{
4629	clk_unregister(*(struct clk **)res);
4630	}
4631
4632	static void devm_clk_hw_unregister_cb(struct device *dev, void *res)
4633	{
4634	clk_hw_unregister(*(struct clk_hw **)res);
4635	}
4636
4637	/**
4638	* devm_clk_register - resource managed clk_register()
4639	* @dev: device that is registering this clock
4640	* @hw: link to hardware-specific clock data
4641	*
4642	* Managed clk_register(). This function is *deprecated*, use devm_clk_hw_register() instead.
4643	*
4644	* Clocks returned from this function are automatically clk_unregister()ed on
4645	* driver detach. See clk_register() for more information.
4646	*/
4647	struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw)
4648	{
4649	struct clk *clk;
4650	struct clk **clkp;
4651
4652	clkp = devres_alloc(devm_clk_unregister_cb, sizeof(*clkp), GFP_KERNEL);
4653	if (!clkp)
4654	return ERR_PTR(error: -ENOMEM);
4655
4656	clk = clk_register(dev, hw);
4657	if (!IS_ERR(ptr: clk)) {
4658	*clkp = clk;
4659	devres_add(dev, res: clkp);
4660	} else {
4661	devres_free(res: clkp);
4662	}
4663
4664	return clk;
4665	}
4666	EXPORT_SYMBOL_GPL(devm_clk_register);
4667
4668	/**
4669	* devm_clk_hw_register - resource managed clk_hw_register()
4670	* @dev: device that is registering this clock
4671	* @hw: link to hardware-specific clock data
4672	*
4673	* Managed clk_hw_register(). Clocks registered by this function are
4674	* automatically clk_hw_unregister()ed on driver detach. See clk_hw_register()
4675	* for more information.
4676	*/
4677	int devm_clk_hw_register(struct device *dev, struct clk_hw *hw)
4678	{
4679	struct clk_hw **hwp;
4680	int ret;
4681
4682	hwp = devres_alloc(devm_clk_hw_unregister_cb, sizeof(*hwp), GFP_KERNEL);
4683	if (!hwp)
4684	return -ENOMEM;
4685
4686	ret = clk_hw_register(dev, hw);
4687	if (!ret) {
4688	*hwp = hw;
4689	devres_add(dev, res: hwp);
4690	} else {
4691	devres_free(res: hwp);
4692	}
4693
4694	return ret;
4695	}
4696	EXPORT_SYMBOL_GPL(devm_clk_hw_register);
4697
4698	static void devm_clk_release(struct device *dev, void *res)
4699	{
4700	clk_put(clk: *(struct clk **)res);
4701	}
4702
4703	/**
4704	* devm_clk_hw_get_clk - resource managed clk_hw_get_clk()
4705	* @dev: device that is registering this clock
4706	* @hw: clk_hw associated with the clk being consumed
4707	* @con_id: connection ID string on device
4708	*
4709	* Managed clk_hw_get_clk(). Clocks got with this function are
4710	* automatically clk_put() on driver detach. See clk_put()
4711	* for more information.
4712	*/
4713	struct clk *devm_clk_hw_get_clk(struct device *dev, struct clk_hw *hw,
4714	const char *con_id)
4715	{
4716	struct clk *clk;
4717	struct clk **clkp;
4718
4719	/* This should not happen because it would mean we have drivers
4720	* passing around clk_hw pointers instead of having the caller use
4721	* proper clk_get() style APIs
4722	*/
4723	WARN_ON_ONCE(dev != hw->core->dev);
4724
4725	clkp = devres_alloc(devm_clk_release, sizeof(*clkp), GFP_KERNEL);
4726	if (!clkp)
4727	return ERR_PTR(error: -ENOMEM);
4728
4729	clk = clk_hw_get_clk(hw, con_id);
4730	if (!IS_ERR(ptr: clk)) {
4731	*clkp = clk;
4732	devres_add(dev, res: clkp);
4733	} else {
4734	devres_free(res: clkp);
4735	}
4736
4737	return clk;
4738	}
4739	EXPORT_SYMBOL_GPL(devm_clk_hw_get_clk);
4740
4741	/*
4742	* clkdev helpers
4743	*/
4744
4745	void __clk_put(struct clk *clk)
4746	{
4747	struct module *owner;
4748
4749	if (!clk || WARN_ON_ONCE(IS_ERR(clk)))
4750	return;
4751
4752	clk_prepare_lock();
4753
4754	/*
4755	* Before calling clk_put, all calls to clk_rate_exclusive_get() from a
4756	* given user should be balanced with calls to clk_rate_exclusive_put()
4757	* and by that same consumer
4758	*/
4759	if (WARN_ON(clk->exclusive_count)) {
4760	/* We voiced our concern, let's sanitize the situation */
4761	clk->core->protect_count -= (clk->exclusive_count - 1);
4762	clk_core_rate_unprotect(core: clk->core);
4763	clk->exclusive_count = 0;
4764	}
4765
4766	clk_core_unlink_consumer(clk);
4767
4768	/* If we had any boundaries on that clock, let's drop them. */
4769	if (clk->min_rate > 0 || clk->max_rate < ULONG_MAX)
4770	clk_set_rate_range_nolock(clk, min: 0, ULONG_MAX);
4771
4772	clk_prepare_unlock();
4773
4774	owner = clk->core->owner;
4775	kref_put(kref: &clk->core->ref, release: __clk_release);
4776	module_put(module: owner);
4777	free_clk(clk);
4778	}
4779
4780	/*** clk rate change notifiers ***/
4781
4782	/**
4783	* clk_notifier_register - add a clk rate change notifier
4784	* @clk: struct clk * to watch
4785	* @nb: struct notifier_block * with callback info
4786	*
4787	* Request notification when clk's rate changes. This uses an SRCU
4788	* notifier because we want it to block and notifier unregistrations are
4789	* uncommon. The callbacks associated with the notifier must not
4790	* re-enter into the clk framework by calling any top-level clk APIs;
4791	* this will cause a nested prepare_lock mutex.
4792	*
4793	* In all notification cases (pre, post and abort rate change) the original
4794	* clock rate is passed to the callback via struct clk_notifier_data.old_rate
4795	* and the new frequency is passed via struct clk_notifier_data.new_rate.
4796	*
4797	* clk_notifier_register() must be called from non-atomic context.
4798	* Returns -EINVAL if called with null arguments, -ENOMEM upon
4799	* allocation failure; otherwise, passes along the return value of
4800	* srcu_notifier_chain_register().
4801	*/
4802	int clk_notifier_register(struct clk *clk, struct notifier_block *nb)
4803	{
4804	struct clk_notifier *cn;
4805	int ret = -ENOMEM;
4806
4807	if (!clk || !nb)
4808	return -EINVAL;
4809
4810	clk_prepare_lock();
4811
4812	/* search the list of notifiers for this clk */
4813	list_for_each_entry(cn, &clk_notifier_list, node)
4814	if (cn->clk == clk)
4815	goto found;
4816
4817	/* if clk wasn't in the notifier list, allocate new clk_notifier */
4818	cn = kzalloc(sizeof(*cn), GFP_KERNEL);
4819	if (!cn)
4820	goto out;
4821
4822	cn->clk = clk;
4823	srcu_init_notifier_head(nh: &cn->notifier_head);
4824
4825	list_add(new: &cn->node, head: &clk_notifier_list);
4826
4827	found:
4828	ret = srcu_notifier_chain_register(nh: &cn->notifier_head, nb);
4829
4830	clk->core->notifier_count++;
4831
4832	out:
4833	clk_prepare_unlock();
4834
4835	return ret;
4836	}
4837	EXPORT_SYMBOL_GPL(clk_notifier_register);
4838
4839	/**
4840	* clk_notifier_unregister - remove a clk rate change notifier
4841	* @clk: struct clk *
4842	* @nb: struct notifier_block * with callback info
4843	*
4844	* Request no further notification for changes to 'clk' and frees memory
4845	* allocated in clk_notifier_register.
4846	*
4847	* Returns -EINVAL if called with null arguments; otherwise, passes
4848	* along the return value of srcu_notifier_chain_unregister().
4849	*/
4850	int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb)
4851	{
4852	struct clk_notifier *cn;
4853	int ret = -ENOENT;
4854
4855	if (!clk || !nb)
4856	return -EINVAL;
4857
4858	clk_prepare_lock();
4859
4860	list_for_each_entry(cn, &clk_notifier_list, node) {
4861	if (cn->clk == clk) {
4862	ret = srcu_notifier_chain_unregister(nh: &cn->notifier_head, nb);
4863
4864	clk->core->notifier_count--;
4865
4866	/* XXX the notifier code should handle this better */
4867	if (!cn->notifier_head.head) {
4868	srcu_cleanup_notifier_head(&cn->notifier_head);
4869	list_del(entry: &cn->node);
4870	kfree(objp: cn);
4871	}
4872	break;
4873	}
4874	}
4875
4876	clk_prepare_unlock();
4877
4878	return ret;
4879	}
4880	EXPORT_SYMBOL_GPL(clk_notifier_unregister);
4881
4882	struct clk_notifier_devres {
4883	struct clk *clk;
4884	struct notifier_block *nb;
4885	};
4886
4887	static void devm_clk_notifier_release(struct device *dev, void *res)
4888	{
4889	struct clk_notifier_devres *devres = res;
4890
4891	clk_notifier_unregister(devres->clk, devres->nb);
4892	}
4893
4894	int devm_clk_notifier_register(struct device *dev, struct clk *clk,
4895	struct notifier_block *nb)
4896	{
4897	struct clk_notifier_devres *devres;
4898	int ret;
4899
4900	devres = devres_alloc(devm_clk_notifier_release,
4901	sizeof(*devres), GFP_KERNEL);
4902
4903	if (!devres)
4904	return -ENOMEM;
4905
4906	ret = clk_notifier_register(clk, nb);
4907	if (!ret) {
4908	devres->clk = clk;
4909	devres->nb = nb;
4910	devres_add(dev, res: devres);
4911	} else {
4912	devres_free(res: devres);
4913	}
4914
4915	return ret;
4916	}
4917	EXPORT_SYMBOL_GPL(devm_clk_notifier_register);
4918
4919	#ifdef CONFIG_OF
4920	static void clk_core_reparent_orphans(void)
4921	{
4922	clk_prepare_lock();
4923	clk_core_reparent_orphans_nolock();
4924	clk_prepare_unlock();
4925	}
4926
4927	/**
4928	* struct of_clk_provider - Clock provider registration structure
4929	* @link: Entry in global list of clock providers
4930	* @node: Pointer to device tree node of clock provider
4931	* @get: Get clock callback. Returns NULL or a struct clk for the
4932	* given clock specifier
4933	* @get_hw: Get clk_hw callback. Returns NULL, ERR_PTR or a
4934	* struct clk_hw for the given clock specifier
4935	* @data: context pointer to be passed into @get callback
4936	*/
4937	struct of_clk_provider {
4938	struct list_head link;
4939
4940	struct device_node *node;
4941	struct clk *(*get)(struct of_phandle_args *clkspec, void *data);
4942	struct clk_hw *(*get_hw)(struct of_phandle_args *clkspec, void *data);
4943	void *data;
4944	};
4945
4946	extern struct of_device_id __clk_of_table;
4947	static const struct of_device_id __clk_of_table_sentinel
4948	__used __section("__clk_of_table_end");
4949
4950	static LIST_HEAD(of_clk_providers);
4951	static DEFINE_MUTEX(of_clk_mutex);
4952
4953	struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
4954	void *data)
4955	{
4956	return data;
4957	}
4958	EXPORT_SYMBOL_GPL(of_clk_src_simple_get);
4959
4960	struct clk_hw *of_clk_hw_simple_get(struct of_phandle_args *clkspec, void *data)
4961	{
4962	return data;
4963	}
4964	EXPORT_SYMBOL_GPL(of_clk_hw_simple_get);
4965
4966	struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data)
4967	{
4968	struct clk_onecell_data *clk_data = data;
4969	unsigned int idx = clkspec->args[0];
4970
4971	if (idx >= clk_data->clk_num) {
4972	pr_err("%s: invalid clock index %u\n", __func__, idx);
4973	return ERR_PTR(error: -EINVAL);
4974	}
4975
4976	return clk_data->clks[idx];
4977	}
4978	EXPORT_SYMBOL_GPL(of_clk_src_onecell_get);
4979
4980	struct clk_hw *
4981	of_clk_hw_onecell_get(struct of_phandle_args *clkspec, void *data)
4982	{
4983	struct clk_hw_onecell_data *hw_data = data;
4984	unsigned int idx = clkspec->args[0];
4985
4986	if (idx >= hw_data->num) {
4987	pr_err("%s: invalid index %u\n", __func__, idx);
4988	return ERR_PTR(error: -EINVAL);
4989	}
4990
4991	return hw_data->hws[idx];
4992	}
4993	EXPORT_SYMBOL_GPL(of_clk_hw_onecell_get);
4994
4995	/**
4996	* of_clk_add_provider() - Register a clock provider for a node
4997	* @np: Device node pointer associated with clock provider
4998	* @clk_src_get: callback for decoding clock
4999	* @data: context pointer for @clk_src_get callback.
5000	*
5001	* This function is *deprecated*. Use of_clk_add_hw_provider() instead.
5002	*/
5003	int of_clk_add_provider(struct device_node *np,
5004	struct clk *(*clk_src_get)(struct of_phandle_args *clkspec,
5005	void *data),
5006	void *data)
5007	{
5008	struct of_clk_provider *cp;
5009	int ret;
5010
5011	if (!np)
5012	return 0;
5013
5014	cp = kzalloc(sizeof(*cp), GFP_KERNEL);
5015	if (!cp)
5016	return -ENOMEM;
5017
5018	cp->node = of_node_get(node: np);
5019	cp->data = data;
5020	cp->get = clk_src_get;
5021
5022	mutex_lock(&of_clk_mutex);
5023	list_add(new: &cp->link, head: &of_clk_providers);
5024	mutex_unlock(lock: &of_clk_mutex);
5025	pr_debug("Added clock from %pOF\n", np);
5026
5027	clk_core_reparent_orphans();
5028
5029	ret = of_clk_set_defaults(node: np, clk_supplier: true);
5030	if (ret < 0)
5031	of_clk_del_provider(np);
5032
5033	fwnode_dev_initialized(fwnode: &np->fwnode, initialized: true);
5034
5035	return ret;
5036	}
5037	EXPORT_SYMBOL_GPL(of_clk_add_provider);
5038
5039	/**
5040	* of_clk_add_hw_provider() - Register a clock provider for a node
5041	* @np: Device node pointer associated with clock provider
5042	* @get: callback for decoding clk_hw
5043	* @data: context pointer for @get callback.
5044	*/
5045	int of_clk_add_hw_provider(struct device_node *np,
5046	struct clk_hw *(*get)(struct of_phandle_args *clkspec,
5047	void *data),
5048	void *data)
5049	{
5050	struct of_clk_provider *cp;
5051	int ret;
5052
5053	if (!np)
5054	return 0;
5055
5056	cp = kzalloc(sizeof(*cp), GFP_KERNEL);
5057	if (!cp)
5058	return -ENOMEM;
5059
5060	cp->node = of_node_get(node: np);
5061	cp->data = data;
5062	cp->get_hw = get;
5063
5064	mutex_lock(&of_clk_mutex);
5065	list_add(new: &cp->link, head: &of_clk_providers);
5066	mutex_unlock(lock: &of_clk_mutex);
5067	pr_debug("Added clk_hw provider from %pOF\n", np);
5068
5069	clk_core_reparent_orphans();
5070
5071	ret = of_clk_set_defaults(node: np, clk_supplier: true);
5072	if (ret < 0)
5073	of_clk_del_provider(np);
5074
5075	fwnode_dev_initialized(fwnode: &np->fwnode, initialized: true);
5076
5077	return ret;
5078	}
5079	EXPORT_SYMBOL_GPL(of_clk_add_hw_provider);
5080
5081	static void devm_of_clk_release_provider(struct device *dev, void *res)
5082	{
5083	of_clk_del_provider(np: *(struct device_node **)res);
5084	}
5085
5086	/*
5087	* We allow a child device to use its parent device as the clock provider node
5088	* for cases like MFD sub-devices where the child device driver wants to use
5089	* devm_*() APIs but not list the device in DT as a sub-node.
5090	*/
5091	static struct device_node *get_clk_provider_node(struct device *dev)
5092	{
5093	struct device_node *np, *parent_np;
5094
5095	np = dev->of_node;
5096	parent_np = dev->parent ? dev->parent->of_node : NULL;
5097
5098	if (!of_property_present(np, propname: "#clock-cells"))
5099	if (of_property_present(np: parent_np, propname: "#clock-cells"))
5100	np = parent_np;
5101
5102	return np;
5103	}
5104
5105	/**
5106	* devm_of_clk_add_hw_provider() - Managed clk provider node registration
5107	* @dev: Device acting as the clock provider (used for DT node and lifetime)
5108	* @get: callback for decoding clk_hw
5109	* @data: context pointer for @get callback
5110	*
5111	* Registers clock provider for given device's node. If the device has no DT
5112	* node or if the device node lacks of clock provider information (#clock-cells)
5113	* then the parent device's node is scanned for this information. If parent node
5114	* has the #clock-cells then it is used in registration. Provider is
5115	* automatically released at device exit.
5116	*
5117	* Return: 0 on success or an errno on failure.
5118	*/
5119	int devm_of_clk_add_hw_provider(struct device *dev,
5120	struct clk_hw *(*get)(struct of_phandle_args *clkspec,
5121	void *data),
5122	void *data)
5123	{
5124	struct device_node **ptr, *np;
5125	int ret;
5126
5127	ptr = devres_alloc(devm_of_clk_release_provider, sizeof(*ptr),
5128	GFP_KERNEL);
5129	if (!ptr)
5130	return -ENOMEM;
5131
5132	np = get_clk_provider_node(dev);
5133	ret = of_clk_add_hw_provider(np, get, data);
5134	if (!ret) {
5135	*ptr = np;
5136	devres_add(dev, res: ptr);
5137	} else {
5138	devres_free(res: ptr);
5139	}
5140
5141	return ret;
5142	}
5143	EXPORT_SYMBOL_GPL(devm_of_clk_add_hw_provider);
5144
5145	/**
5146	* of_clk_del_provider() - Remove a previously registered clock provider
5147	* @np: Device node pointer associated with clock provider
5148	*/
5149	void of_clk_del_provider(struct device_node *np)
5150	{
5151	struct of_clk_provider *cp;
5152
5153	if (!np)
5154	return;
5155
5156	mutex_lock(&of_clk_mutex);
5157	list_for_each_entry(cp, &of_clk_providers, link) {
5158	if (cp->node == np) {
5159	list_del(entry: &cp->link);
5160	fwnode_dev_initialized(fwnode: &np->fwnode, initialized: false);
5161	of_node_put(node: cp->node);
5162	kfree(objp: cp);
5163	break;
5164	}
5165	}
5166	mutex_unlock(lock: &of_clk_mutex);
5167	}
5168	EXPORT_SYMBOL_GPL(of_clk_del_provider);
5169
5170	/**
5171	* of_parse_clkspec() - Parse a DT clock specifier for a given device node
5172	* @np: device node to parse clock specifier from
5173	* @index: index of phandle to parse clock out of. If index < 0, @name is used
5174	* @name: clock name to find and parse. If name is NULL, the index is used
5175	* @out_args: Result of parsing the clock specifier
5176	*
5177	* Parses a device node's "clocks" and "clock-names" properties to find the
5178	* phandle and cells for the index or name that is desired. The resulting clock
5179	* specifier is placed into @out_args, or an errno is returned when there's a
5180	* parsing error. The @index argument is ignored if @name is non-NULL.
5181	*
5182	* Example:
5183	*
5184	* phandle1: clock-controller@1 {
5185	* #clock-cells = <2>;
5186	* }
5187	*
5188	* phandle2: clock-controller@2 {
5189	* #clock-cells = <1>;
5190	* }
5191	*
5192	* clock-consumer@3 {
5193	* clocks = <&phandle1 1 2 &phandle2 3>;
5194	* clock-names = "name1", "name2";
5195	* }
5196	*
5197	* To get a device_node for `clock-controller@2' node you may call this
5198	* function a few different ways:
5199	*
5200	* of_parse_clkspec(clock-consumer@3, -1, "name2", &args);
5201	* of_parse_clkspec(clock-consumer@3, 1, NULL, &args);
5202	* of_parse_clkspec(clock-consumer@3, 1, "name2", &args);
5203	*
5204	* Return: 0 upon successfully parsing the clock specifier. Otherwise, -ENOENT
5205	* if @name is NULL or -EINVAL if @name is non-NULL and it can't be found in
5206	* the "clock-names" property of @np.
5207	*/
5208	static int of_parse_clkspec(const struct device_node *np, int index,
5209	const char *name, struct of_phandle_args *out_args)
5210	{
5211	int ret = -ENOENT;
5212
5213	/* Walk up the tree of devices looking for a clock property that matches */
5214	while (np) {
5215	/*
5216	* For named clocks, first look up the name in the
5217	* "clock-names" property. If it cannot be found, then index
5218	* will be an error code and of_parse_phandle_with_args() will
5219	* return -EINVAL.
5220	*/
5221	if (name)
5222	index = of_property_match_string(np, propname: "clock-names", string: name);
5223	ret = of_parse_phandle_with_args(np, list_name: "clocks", cells_name: "#clock-cells",
5224	index, out_args);
5225	if (!ret)
5226	break;
5227	if (name && index >= 0)
5228	break;
5229
5230	/*
5231	* No matching clock found on this node. If the parent node
5232	* has a "clock-ranges" property, then we can try one of its
5233	* clocks.
5234	*/
5235	np = np->parent;
5236	if (np && !of_property_present(np, propname: "clock-ranges"))
5237	break;
5238	index = 0;
5239	}
5240
5241	return ret;
5242	}
5243
5244	static struct clk_hw *
5245	__of_clk_get_hw_from_provider(struct of_clk_provider *provider,
5246	struct of_phandle_args *clkspec)
5247	{
5248	struct clk *clk;
5249
5250	if (provider->get_hw)
5251	return provider->get_hw(clkspec, provider->data);
5252
5253	clk = provider->get(clkspec, provider->data);
5254	if (IS_ERR(ptr: clk))
5255	return ERR_CAST(ptr: clk);
5256	return __clk_get_hw(clk);
5257	}
5258
5259	static struct clk_hw *
5260	of_clk_get_hw_from_clkspec(struct of_phandle_args *clkspec)
5261	{
5262	struct of_clk_provider *provider;
5263	struct clk_hw *hw = ERR_PTR(error: -EPROBE_DEFER);
5264
5265	if (!clkspec)
5266	return ERR_PTR(error: -EINVAL);
5267
5268	/* Check if node in clkspec is in disabled/fail state */
5269	if (!of_device_is_available(device: clkspec->np))
5270	return ERR_PTR(error: -ENOENT);
5271
5272	mutex_lock(&of_clk_mutex);
5273	list_for_each_entry(provider, &of_clk_providers, link) {
5274	if (provider->node == clkspec->np) {
5275	hw = __of_clk_get_hw_from_provider(provider, clkspec);
5276	if (!IS_ERR(ptr: hw))
5277	break;
5278	}
5279	}
5280	mutex_unlock(lock: &of_clk_mutex);
5281
5282	return hw;
5283	}
5284
5285	/**
5286	* of_clk_get_from_provider() - Lookup a clock from a clock provider
5287	* @clkspec: pointer to a clock specifier data structure
5288	*
5289	* This function looks up a struct clk from the registered list of clock
5290	* providers, an input is a clock specifier data structure as returned
5291	* from the of_parse_phandle_with_args() function call.
5292	*/
5293	struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
5294	{
5295	struct clk_hw *hw = of_clk_get_hw_from_clkspec(clkspec);
5296
5297	return clk_hw_create_clk(NULL, hw, NULL, con_id: __func__);
5298	}
5299	EXPORT_SYMBOL_GPL(of_clk_get_from_provider);
5300
5301	struct clk_hw *of_clk_get_hw(struct device_node *np, int index,
5302	const char *con_id)
5303	{
5304	int ret;
5305	struct clk_hw *hw;
5306	struct of_phandle_args clkspec;
5307
5308	ret = of_parse_clkspec(np, index, name: con_id, out_args: &clkspec);
5309	if (ret)
5310	return ERR_PTR(error: ret);
5311
5312	hw = of_clk_get_hw_from_clkspec(clkspec: &clkspec);
5313	of_node_put(node: clkspec.np);
5314
5315	return hw;
5316	}
5317
5318	static struct clk *__of_clk_get(struct device_node *np,
5319	int index, const char *dev_id,
5320	const char *con_id)
5321	{
5322	struct clk_hw *hw = of_clk_get_hw(np, index, con_id);
5323
5324	return clk_hw_create_clk(NULL, hw, dev_id, con_id);
5325	}
5326
5327	struct clk *of_clk_get(struct device_node *np, int index)
5328	{
5329	return __of_clk_get(np, index, dev_id: np->full_name, NULL);
5330	}
5331	EXPORT_SYMBOL(of_clk_get);
5332
5333	/**
5334	* of_clk_get_by_name() - Parse and lookup a clock referenced by a device node
5335	* @np: pointer to clock consumer node
5336	* @name: name of consumer's clock input, or NULL for the first clock reference
5337	*
5338	* This function parses the clocks and clock-names properties,
5339	* and uses them to look up the struct clk from the registered list of clock
5340	* providers.
5341	*/
5342	struct clk *of_clk_get_by_name(struct device_node *np, const char *name)
5343	{
5344	if (!np)
5345	return ERR_PTR(error: -ENOENT);
5346
5347	return __of_clk_get(np, index: 0, dev_id: np->full_name, con_id: name);
5348	}
5349	EXPORT_SYMBOL(of_clk_get_by_name);
5350
5351	/**
5352	* of_clk_get_parent_count() - Count the number of clocks a device node has
5353	* @np: device node to count
5354	*
5355	* Returns: The number of clocks that are possible parents of this node
5356	*/
5357	unsigned int of_clk_get_parent_count(const struct device_node *np)
5358	{
5359	int count;
5360
5361	count = of_count_phandle_with_args(np, list_name: "clocks", cells_name: "#clock-cells");
5362	if (count < 0)
5363	return 0;
5364
5365	return count;
5366	}
5367	EXPORT_SYMBOL_GPL(of_clk_get_parent_count);
5368
5369	const char *of_clk_get_parent_name(const struct device_node *np, int index)
5370	{
5371	struct of_phandle_args clkspec;
5372	const char *clk_name;
5373	bool found = false;
5374	u32 pv;
5375	int rc;
5376	int count;
5377	struct clk *clk;
5378
5379	rc = of_parse_phandle_with_args(np, list_name: "clocks", cells_name: "#clock-cells", index,
5380	out_args: &clkspec);
5381	if (rc)
5382	return NULL;
5383
5384	index = clkspec.args_count ? clkspec.args[0] : 0;
5385	count = 0;
5386
5387	/* if there is an indices property, use it to transfer the index
5388	* specified into an array offset for the clock-output-names property.
5389	*/
5390	of_property_for_each_u32(clkspec.np, "clock-indices", pv) {
5391	if (index == pv) {
5392	index = count;
5393	found = true;
5394	break;
5395	}
5396	count++;
5397	}
5398	/* We went off the end of 'clock-indices' without finding it */
5399	if (of_property_present(np: clkspec.np, propname: "clock-indices") && !found) {
5400	of_node_put(node: clkspec.np);
5401	return NULL;
5402	}
5403
5404	if (of_property_read_string_index(np: clkspec.np, propname: "clock-output-names",
5405	index,
5406	output: &clk_name) < 0) {
5407	/*
5408	* Best effort to get the name if the clock has been
5409	* registered with the framework. If the clock isn't
5410	* registered, we return the node name as the name of
5411	* the clock as long as #clock-cells = 0.
5412	*/
5413	clk = of_clk_get_from_provider(&clkspec);
5414	if (IS_ERR(ptr: clk)) {
5415	if (clkspec.args_count == 0)
5416	clk_name = clkspec.np->name;
5417	else
5418	clk_name = NULL;
5419	} else {
5420	clk_name = __clk_get_name(clk);
5421	clk_put(clk);
5422	}
5423	}
5424
5425
5426	of_node_put(node: clkspec.np);
5427	return clk_name;
5428	}
5429	EXPORT_SYMBOL_GPL(of_clk_get_parent_name);
5430
5431	/**
5432	* of_clk_parent_fill() - Fill @parents with names of @np's parents and return
5433	* number of parents
5434	* @np: Device node pointer associated with clock provider
5435	* @parents: pointer to char array that hold the parents' names
5436	* @size: size of the @parents array
5437	*
5438	* Return: number of parents for the clock node.
5439	*/
5440	int of_clk_parent_fill(struct device_node *np, const char **parents,
5441	unsigned int size)
5442	{
5443	unsigned int i = 0;
5444
5445	while (i < size && (parents[i] = of_clk_get_parent_name(np, i)) != NULL)
5446	i++;
5447
5448	return i;
5449	}
5450	EXPORT_SYMBOL_GPL(of_clk_parent_fill);
5451
5452	struct clock_provider {
5453	void (*clk_init_cb)(struct device_node *);
5454	struct device_node *np;
5455	struct list_head node;
5456	};
5457
5458	/*
5459	* This function looks for a parent clock. If there is one, then it
5460	* checks that the provider for this parent clock was initialized, in
5461	* this case the parent clock will be ready.
5462	*/
5463	static int parent_ready(struct device_node *np)
5464	{
5465	int i = 0;
5466
5467	while (true) {
5468	struct clk *clk = of_clk_get(np, i);
5469
5470	/* this parent is ready we can check the next one */
5471	if (!IS_ERR(ptr: clk)) {
5472	clk_put(clk);
5473	i++;
5474	continue;
5475	}
5476
5477	/* at least one parent is not ready, we exit now */
5478	if (PTR_ERR(ptr: clk) == -EPROBE_DEFER)
5479	return 0;
5480
5481	/*
5482	* Here we make assumption that the device tree is
5483	* written correctly. So an error means that there is
5484	* no more parent. As we didn't exit yet, then the
5485	* previous parent are ready. If there is no clock
5486	* parent, no need to wait for them, then we can
5487	* consider their absence as being ready
5488	*/
5489	return 1;
5490	}
5491	}
5492
5493	/**
5494	* of_clk_detect_critical() - set CLK_IS_CRITICAL flag from Device Tree
5495	* @np: Device node pointer associated with clock provider
5496	* @index: clock index
5497	* @flags: pointer to top-level framework flags
5498	*
5499	* Detects if the clock-critical property exists and, if so, sets the
5500	* corresponding CLK_IS_CRITICAL flag.
5501	*
5502	* Do not use this function. It exists only for legacy Device Tree
5503	* bindings, such as the one-clock-per-node style that are outdated.
5504	* Those bindings typically put all clock data into .dts and the Linux
5505	* driver has no clock data, thus making it impossible to set this flag
5506	* correctly from the driver. Only those drivers may call
5507	* of_clk_detect_critical from their setup functions.
5508	*
5509	* Return: error code or zero on success
5510	*/
5511	int of_clk_detect_critical(struct device_node *np, int index,
5512	unsigned long *flags)
5513	{
5514	uint32_t idx;
5515
5516	if (!np || !flags)
5517	return -EINVAL;
5518
5519	of_property_for_each_u32(np, "clock-critical", idx)
5520	if (index == idx)
5521	*flags |= CLK_IS_CRITICAL;
5522
5523	return 0;
5524	}
5525
5526	/**
5527	* of_clk_init() - Scan and init clock providers from the DT
5528	* @matches: array of compatible values and init functions for providers.
5529	*
5530	* This function scans the device tree for matching clock providers
5531	* and calls their initialization functions. It also does it by trying
5532	* to follow the dependencies.
5533	*/
5534	void __init of_clk_init(const struct of_device_id *matches)
5535	{
5536	const struct of_device_id *match;
5537	struct device_node *np;
5538	struct clock_provider *clk_provider, *next;
5539	bool is_init_done;
5540	bool force = false;
5541	LIST_HEAD(clk_provider_list);
5542
5543	if (!matches)
5544	matches = &__clk_of_table;
5545
5546	/* First prepare the list of the clocks providers */
5547	for_each_matching_node_and_match(np, matches, &match) {
5548	struct clock_provider *parent;
5549
5550	if (!of_device_is_available(device: np))
5551	continue;
5552
5553	parent = kzalloc(sizeof(*parent), GFP_KERNEL);
5554	if (!parent) {
5555	list_for_each_entry_safe(clk_provider, next,
5556	&clk_provider_list, node) {
5557	list_del(entry: &clk_provider->node);
5558	of_node_put(node: clk_provider->np);
5559	kfree(objp: clk_provider);
5560	}
5561	of_node_put(node: np);
5562	return;
5563	}
5564
5565	parent->clk_init_cb = match->data;
5566	parent->np = of_node_get(node: np);
5567	list_add_tail(new: &parent->node, head: &clk_provider_list);
5568	}
5569
5570	while (!list_empty(head: &clk_provider_list)) {
5571	is_init_done = false;
5572	list_for_each_entry_safe(clk_provider, next,
5573	&clk_provider_list, node) {
5574	if (force || parent_ready(np: clk_provider->np)) {
5575
5576	/* Don't populate platform devices */
5577	of_node_set_flag(n: clk_provider->np,
5578	OF_POPULATED);
5579
5580	clk_provider->clk_init_cb(clk_provider->np);
5581	of_clk_set_defaults(node: clk_provider->np, clk_supplier: true);
5582
5583	list_del(entry: &clk_provider->node);
5584	of_node_put(node: clk_provider->np);
5585	kfree(objp: clk_provider);
5586	is_init_done = true;
5587	}
5588	}
5589
5590	/*
5591	* We didn't manage to initialize any of the
5592	* remaining providers during the last loop, so now we
5593	* initialize all the remaining ones unconditionally
5594	* in case the clock parent was not mandatory
5595	*/
5596	if (!is_init_done)
5597	force = true;
5598	}
5599	}
5600	#endif
5601