~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,11 +1,7 @@
	1	+// SPDX-License-Identifier: GPL-2.0
1	2	/*
2	3	* Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
3	4	* Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
4		- * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
5		- *
6		- * This program is free software; you can redistribute it and/or modify
7		- * it under the terms of the GNU General Public License version 2 as
8		- * published by the Free Software Foundation.
9	5	*
10	6	* Standard functionality for the common clock API. See Documentation/driver-api/clk.rst
11	7	*/
..	..	@@ -25,10 +21,6 @@
25	21	#include <linux/pm_runtime.h>
26	22	#include <linux/sched.h>
27	23	#include <linux/clkdev.h>
28		-#include <linux/uaccess.h>
29		-#include <linux/of_platform.h>
30		-#include <linux/pm_opp.h>
31		-#include <linux/regulator/consumer.h>
32	24
33	25	#include "clk.h"
34	26
..	..	@@ -51,17 +43,15 @@
51	43	NULL,
52	44	};
53	45
54		-/*
55		- * clk_rate_change_list is used during clk_core_set_rate_nolock() calls to
56		- * handle vdd_class vote tracking. core->rate_change_node is added to
57		- * clk_rate_change_list when core->new_rate requires a different voltage level
58		- * (core->new_vdd_class_vote) than core->vdd_class_vote. Elements are removed
59		- * from the list after unvoting core->vdd_class_vote immediately before
60		- * returning from clk_core_set_rate_nolock().
61		- */
62		-static LIST_HEAD(clk_rate_change_list);
63		-
64	46	/* private data structures */
	47	+
	48	+struct clk_parent_map {
	49	+ const struct clk_hw *hw;
	50	+ struct clk_core *core;
	51	+ const char *fw_name;
	52	+ const char *name;
	53	+ int index;
	54	+};
65	55
66	56	struct clk_core {
67	57	const char *name;
..	..	@@ -69,11 +59,11 @@
69	59	struct clk_hw *hw;
70	60	struct module *owner;
71	61	struct device *dev;
	62	+ struct device_node *of_node;
72	63	struct clk_core *parent;
73		- const char **parent_names;
74		- struct clk_core **parents;
75		- unsigned int num_parents;
76		- unsigned int new_parent_index;
	64	+ struct clk_parent_map *parents;
	65	+ u8 num_parents;
	66	+ u8 new_parent_index;
77	67	unsigned long rate;
78	68	unsigned long req_rate;
79	69	unsigned long new_rate;
..	..	@@ -87,8 +77,6 @@
87	77	unsigned int enable_count;
88	78	unsigned int prepare_count;
89	79	unsigned int protect_count;
90		- bool need_handoff_enable;
91		- bool need_handoff_prepare;
92	80	unsigned long min_rate;
93	81	unsigned long max_rate;
94	82	unsigned long accuracy;
..	..	@@ -98,17 +86,11 @@
98	86	struct hlist_node child_node;
99	87	struct hlist_head clks;
100	88	unsigned int notifier_count;
101		-#ifdef CONFIG_COMMON_CLK_DEBUGFS
	89	+#ifdef CONFIG_DEBUG_FS
102	90	struct dentry *dentry;
103	91	struct hlist_node debug_node;
104	92	#endif
105	93	struct kref ref;
106		- struct clk_vdd_class *vdd_class;
107		- int vdd_class_vote;
108		- int new_vdd_class_vote;
109		- struct list_head rate_change_node;
110		- unsigned long *rate_max;
111		- int num_rate_max;
112	94	};
113	95
114	96	#define CREATE_TRACE_POINTS
..	..	@@ -116,6 +98,7 @@
116	98
117	99	struct clk {
118	100	struct clk_core *core;
	101	+ struct device *dev;
119	102	const char *dev_id;
120	103	const char *con_id;
121	104	unsigned long min_rate;
..	..	@@ -270,6 +253,17 @@
270	253	}
271	254	}
272	255
	256	+ /*
	257	+ * This could be called with the enable lock held, or from atomic
	258	+ * context. If the parent isn't enabled already, we can't do
	259	+ * anything here. We can also assume this clock isn't enabled.
	260	+ */
	261	+ if ((core->flags & CLK_OPS_PARENT_ENABLE) && core->parent)
	262	+ if (!clk_core_is_enabled(core->parent)) {
	263	+ ret = false;
	264	+ goto done;
	265	+ }
	266	+
273	267	ret = core->ops->is_enabled(core->hw);
274	268	done:
275	269	if (core->rpm_enabled)
..	..	@@ -353,17 +347,124 @@
353	347	return NULL;
354	348	}
355	349
	350	+#ifdef CONFIG_OF
	351	+static int of_parse_clkspec(const struct device_node *np, int index,
	352	+ const char name, struct of_phandle_args out_args);
	353	+static struct clk_hw *
	354	+of_clk_get_hw_from_clkspec(struct of_phandle_args *clkspec);
	355	+#else
	356	+static inline int of_parse_clkspec(const struct device_node *np, int index,
	357	+ const char *name,
	358	+ struct of_phandle_args *out_args)
	359	+{
	360	+ return -ENOENT;
	361	+}
	362	+static inline struct clk_hw *
	363	+of_clk_get_hw_from_clkspec(struct of_phandle_args *clkspec)
	364	+{
	365	+ return ERR_PTR(-ENOENT);
	366	+}
	367	+#endif
	368	+
	369	+/**
	370	+ * clk_core_get - Find the clk_core parent of a clk
	371	+ * @core: clk to find parent of
	372	+ * @p_index: parent index to search for
	373	+ *
	374	+ * This is the preferred method for clk providers to find the parent of a
	375	+ * clk when that parent is external to the clk controller. The parent_names
	376	+ * array is indexed and treated as a local name matching a string in the device
	377	+ * node's 'clock-names' property or as the 'con_id' matching the device's
	378	+ * dev_name() in a clk_lookup. This allows clk providers to use their own
	379	+ * namespace instead of looking for a globally unique parent string.
	380	+ *
	381	+ * For example the following DT snippet would allow a clock registered by the
	382	+ * clock-controller@c001 that has a clk_init_data::parent_data array
	383	+ * with 'xtal' in the 'name' member to find the clock provided by the
	384	+ * clock-controller@f00abcd without needing to get the globally unique name of
	385	+ * the xtal clk.
	386	+ *
	387	+ * parent: clock-controller@f00abcd {
	388	+ * reg = <0xf00abcd 0xabcd>;
	389	+ * #clock-cells = <0>;
	390	+ * };
	391	+ *
	392	+ * clock-controller@c001 {
	393	+ * reg = <0xc001 0xf00d>;
	394	+ * clocks = <&parent>;
	395	+ * clock-names = "xtal";
	396	+ * #clock-cells = <1>;
	397	+ * };
	398	+ *
	399	+ * Returns: -ENOENT when the provider can't be found or the clk doesn't
	400	+ * exist in the provider or the name can't be found in the DT node or
	401	+ * in a clkdev lookup. NULL when the provider knows about the clk but it
	402	+ * isn't provided on this system.
	403	+ * A valid clk_core pointer when the clk can be found in the provider.
	404	+ */
	405	+static struct clk_core clk_core_get(struct clk_core core, u8 p_index)
	406	+{
	407	+ const char *name = core->parents[p_index].fw_name;
	408	+ int index = core->parents[p_index].index;
	409	+ struct clk_hw *hw = ERR_PTR(-ENOENT);
	410	+ struct device *dev = core->dev;
	411	+ const char *dev_id = dev ? dev_name(dev) : NULL;
	412	+ struct device_node *np = core->of_node;
	413	+ struct of_phandle_args clkspec;
	414	+
	415	+ if (np && (name \|\| index >= 0) &&
	416	+ !of_parse_clkspec(np, index, name, &clkspec)) {
	417	+ hw = of_clk_get_hw_from_clkspec(&clkspec);
	418	+ of_node_put(clkspec.np);
	419	+ } else if (name) {
	420	+ /*
	421	+ * If the DT search above couldn't find the provider fallback to
	422	+ * looking up via clkdev based clk_lookups.
	423	+ */
	424	+ hw = clk_find_hw(dev_id, name);
	425	+ }
	426	+
	427	+ if (IS_ERR(hw))
	428	+ return ERR_CAST(hw);
	429	+
	430	+ return hw->core;
	431	+}
	432	+
	433	+static void clk_core_fill_parent_index(struct clk_core *core, u8 index)
	434	+{
	435	+ struct clk_parent_map *entry = &core->parents[index];
	436	+ struct clk_core *parent = ERR_PTR(-ENOENT);
	437	+
	438	+ if (entry->hw) {
	439	+ parent = entry->hw->core;
	440	+ /*
	441	+ * We have a direct reference but it isn't registered yet?
	442	+ * Orphan it and let clk_reparent() update the orphan status
	443	+ * when the parent is registered.
	444	+ */
	445	+ if (!parent)
	446	+ parent = ERR_PTR(-EPROBE_DEFER);
	447	+ } else {
	448	+ parent = clk_core_get(core, index);
	449	+ if (PTR_ERR(parent) == -ENOENT && entry->name)
	450	+ parent = clk_core_lookup(entry->name);
	451	+ }
	452	+
	453	+ /* Only cache it if it's not an error */
	454	+ if (!IS_ERR(parent))
	455	+ entry->core = parent;
	456	+}
	457	+
356	458	static struct clk_core clk_core_get_parent_by_index(struct clk_core core,
357	459	u8 index)
358	460	{
359		- if (!core \|\| index >= core->num_parents)
	461	+ if (!core \|\| index >= core->num_parents \|\| !core->parents)
360	462	return NULL;
361	463
362		- if (!core->parents[index])
363		- core->parents[index] =
364		- clk_core_lookup(core->parent_names[index]);
	464	+ if (!core->parents[index].core)
	465	+ clk_core_fill_parent_index(core, index);
365	466
366		- return core->parents[index];
	467	+ return core->parents[index].core;
367	468	}
368	469
369	470	struct clk_hw *
..	..	@@ -384,23 +485,18 @@
384	485
385	486	static unsigned long clk_core_get_rate_nolock(struct clk_core *core)
386	487	{
387		- unsigned long ret;
	488	+ if (!core)
	489	+ return 0;
388	490
389		- if (!core) {
390		- ret = 0;
391		- goto out;
392		- }
	491	+ if (!core->num_parents \|\| core->parent)
	492	+ return core->rate;
393	493
394		- ret = core->rate;
395		-
396		- if (!core->num_parents)
397		- goto out;
398		-
399		- if (!core->parent)
400		- ret = 0;
401		-
402		-out:
403		- return ret;
	494	+ /*
	495	+ * Clk must have a parent because num_parents > 0 but the parent isn't
	496	+ * known yet. Best to return 0 as the rate of this clk until we can
	497	+ * properly recalc the rate based on the parent's rate.
	498	+ */
	499	+ return 0;
404	500	}
405	501
406	502	unsigned long clk_hw_get_rate(const struct clk_hw *hw)
..	..	@@ -409,19 +505,13 @@
409	505	}
410	506	EXPORT_SYMBOL_GPL(clk_hw_get_rate);
411	507
412		-static unsigned long __clk_get_accuracy(struct clk_core *core)
	508	+static unsigned long clk_core_get_accuracy_no_lock(struct clk_core *core)
413	509	{
414	510	if (!core)
415	511	return 0;
416	512
417	513	return core->accuracy;
418	514	}
419		-
420		-unsigned long __clk_get_flags(struct clk *clk)
421		-{
422		- return !clk ? 0 : clk->core->flags;
423		-}
424		-EXPORT_SYMBOL_GPL(__clk_get_flags);
425	515
426	516	unsigned long clk_hw_get_flags(const struct clk_hw *hw)
427	517	{
..	..	@@ -439,6 +529,7 @@
439	529	{
440	530	return clk_core_rate_is_protected(hw->core);
441	531	}
	532	+EXPORT_SYMBOL_GPL(clk_hw_rate_is_protected);
442	533
443	534	bool clk_hw_is_enabled(const struct clk_hw *hw)
444	535	{
..	..	@@ -541,6 +632,8 @@
541	632	{
542	633	struct clk *clk_user;
543	634
	635	+ lockdep_assert_held(&prepare_lock);
	636	+
544	637	*min_rate = core->min_rate;
545	638	*max_rate = core->max_rate;
546	639
..	..	@@ -549,6 +642,24 @@
549	642
550	643	hlist_for_each_entry(clk_user, &core->clks, clks_node)
551	644	max_rate = min(max_rate, clk_user->max_rate);
	645	+}
	646	+
	647	+static bool clk_core_check_boundaries(struct clk_core *core,
	648	+ unsigned long min_rate,
	649	+ unsigned long max_rate)
	650	+{
	651	+ struct clk *user;
	652	+
	653	+ lockdep_assert_held(&prepare_lock);
	654	+
	655	+ if (min_rate > core->max_rate \|\| max_rate < core->min_rate)
	656	+ return false;
	657	+
	658	+ hlist_for_each_entry(user, &core->clks, clks_node)
	659	+ if (min_rate > user->max_rate \|\| max_rate < user->min_rate)
	660	+ return false;
	661	+
	662	+ return true;
552	663	}
553	664
554	665	void clk_hw_set_rate_range(struct clk_hw *hw, unsigned long min_rate,
..	..	@@ -560,29 +671,15 @@
560	671	EXPORT_SYMBOL_GPL(clk_hw_set_rate_range);
561	672
562	673	/*
563		- * Aggregate the rate of all the enabled child nodes and exclude that
564		- * of the child node for which this request was made.
565		- */
566		-unsigned long clk_aggregate_rate(struct clk_hw *hw,
567		- const struct clk_core *parent)
568		-{
569		- struct clk_core *child;
570		- unsigned long aggre_rate = 0;
571		-
572		- hlist_for_each_entry(child, &parent->children, child_node) {
573		- if (child->enable_count &&
574		- strcmp(child->name, hw->init->name))
575		- aggre_rate = max(child->rate, aggre_rate);
576		- }
577		-
578		- return aggre_rate;
579		-}
580		-EXPORT_SYMBOL_GPL(clk_aggregate_rate);
581		-
582		-/*
	674	+ * __clk_mux_determine_rate - clk_ops::determine_rate implementation for a mux type clk
	675	+ * @hw: mux type clk to determine rate on
	676	+ * @req: rate request, also used to return preferred parent and frequencies
	677	+ *
583	678	* Helper for finding best parent to provide a given frequency. This can be used
584	679	* directly as a determine_rate callback (e.g. for a mux), or from a more
585	680	* complex clock that may combine a mux with other operations.
	681	+ *
	682	+ * Returns: 0 on success, -EERROR value on error
586	683	*/
587	684	int __clk_mux_determine_rate(struct clk_hw *hw,
588	685	struct clk_rate_request *req)
..	..	@@ -597,201 +694,6 @@
597	694	return clk_mux_determine_rate_flags(hw, req, CLK_MUX_ROUND_CLOSEST);
598	695	}
599	696	EXPORT_SYMBOL_GPL(__clk_mux_determine_rate_closest);
600		-
601		-/*
602		- * Find the voltage level required for a given clock rate.
603		- */
604		-static int clk_find_vdd_level(struct clk_core *clk, unsigned long rate)
605		-{
606		- int level;
607		-
608		- /*
609		- * For certain PLLs, due to the limitation in the bits allocated for
610		- * programming the fractional divider, the actual rate of the PLL will
611		- * be slightly higher than the requested rate (in the order of several
612		- * Hz). To accommodate this difference, convert the FMAX rate and the
613		- * clock frequency to KHz and use that for deriving the voltage level.
614		- */
615		- for (level = 0; level < clk->num_rate_max; level++)
616		- if (DIV_ROUND_CLOSEST(rate, 1000) <=
617		- DIV_ROUND_CLOSEST(clk->rate_max[level], 1000) &&
618		- clk->rate_max[level] > 0)
619		- break;
620		-
621		- if (level == clk->num_rate_max) {
622		- pr_err("Rate %lu for %s is greater than highest Fmax\n", rate,
623		- clk->name);
624		- return -EINVAL;
625		- }
626		-
627		- return level;
628		-}
629		-
630		-/*
631		- * Update voltage level given the current votes.
632		- */
633		-static int clk_update_vdd(struct clk_vdd_class *vdd_class)
634		-{
635		- int level, rc = 0, i, ignore;
636		- struct regulator **r = vdd_class->regulator;
637		- int *uv = vdd_class->vdd_uv;
638		- int n_reg = vdd_class->num_regulators;
639		- int cur_lvl = vdd_class->cur_level;
640		- int max_lvl = vdd_class->num_levels - 1;
641		- int cur_base = cur_lvl * n_reg;
642		- int new_base;
643		-
644		- /* aggregate votes */
645		- for (level = max_lvl; level > 0; level--)
646		- if (vdd_class->level_votes[level])
647		- break;
648		-
649		- if (level == cur_lvl)
650		- return 0;
651		-
652		- max_lvl = max_lvl * n_reg;
653		- new_base = level * n_reg;
654		-
655		- for (i = 0; i < vdd_class->num_regulators; i++) {
656		- pr_debug("Set Voltage level Min %d, Max %d\n", uv[new_base + i],
657		- uv[max_lvl + i]);
658		- rc = regulator_set_voltage(r[i], uv[new_base + i], INT_MAX);
659		- if (rc)
660		- goto set_voltage_fail;
661		-
662		- if (cur_lvl == 0 \|\| cur_lvl == vdd_class->num_levels)
663		- rc = regulator_enable(r[i]);
664		- else if (level == 0)
665		- rc = regulator_disable(r[i]);
666		- if (rc)
667		- goto enable_disable_fail;
668		- }
669		-
670		- if (vdd_class->set_vdd && !vdd_class->num_regulators)
671		- rc = vdd_class->set_vdd(vdd_class, level);
672		-
673		- if (!rc)
674		- vdd_class->cur_level = level;
675		-
676		- return rc;
677		-
678		-enable_disable_fail:
679		- regulator_set_voltage(r[i], uv[cur_base + i], INT_MAX);
680		-
681		-set_voltage_fail:
682		- for (i--; i >= 0; i--) {
683		- regulator_set_voltage(r[i], uv[cur_base + i], INT_MAX);
684		- if (cur_lvl == 0 \|\| cur_lvl == vdd_class->num_levels)
685		- regulator_disable(r[i]);
686		- else if (level == 0)
687		- ignore = regulator_enable(r[i]);
688		- }
689		-
690		- return rc;
691		-}
692		-
693		-/*
694		- * Vote for a voltage level.
695		- */
696		-int clk_vote_vdd_level(struct clk_vdd_class *vdd_class, int level)
697		-{
698		- int rc = 0;
699		-
700		- if (level >= vdd_class->num_levels)
701		- return -EINVAL;
702		-
703		- mutex_lock(&vdd_class->lock);
704		-
705		- vdd_class->level_votes[level]++;
706		-
707		- rc = clk_update_vdd(vdd_class);
708		- if (rc)
709		- vdd_class->level_votes[level]--;
710		-
711		- mutex_unlock(&vdd_class->lock);
712		-
713		- return rc;
714		-}
715		-EXPORT_SYMBOL_GPL(clk_vote_vdd_level);
716		-
717		-/*
718		- * Remove vote for a voltage level.
719		- */
720		-int clk_unvote_vdd_level(struct clk_vdd_class *vdd_class, int level)
721		-{
722		- int rc = 0;
723		-
724		- if (level >= vdd_class->num_levels)
725		- return -EINVAL;
726		-
727		- mutex_lock(&vdd_class->lock);
728		-
729		- if (WARN(!vdd_class->level_votes[level],
730		- "Reference counts are incorrect for %s level %d\n",
731		- vdd_class->class_name, level)) {
732		- rc = -EINVAL;
733		- goto out;
734		- }
735		-
736		- vdd_class->level_votes[level]--;
737		-
738		- rc = clk_update_vdd(vdd_class);
739		- if (rc)
740		- vdd_class->level_votes[level]++;
741		-
742		-out:
743		- mutex_unlock(&vdd_class->lock);
744		- return rc;
745		-}
746		-EXPORT_SYMBOL_GPL(clk_unvote_vdd_level);
747		-
748		-/*
749		- * Vote for a voltage level corresponding to a clock's rate.
750		- */
751		-int clk_vote_rate_vdd(struct clk_core *core, unsigned long rate)
752		-{
753		- int level;
754		-
755		- if (!core->vdd_class)
756		- return 0;
757		-
758		- level = clk_find_vdd_level(core, rate);
759		- if (level < 0)
760		- return level;
761		-
762		- return clk_vote_vdd_level(core->vdd_class, level);
763		-}
764		-EXPORT_SYMBOL_GPL(clk_vote_rate_vdd);
765		-
766		-/*
767		- * Remove vote for a voltage level corresponding to a clock's rate.
768		- */
769		-void clk_unvote_rate_vdd(struct clk_core *core, unsigned long rate)
770		-{
771		- int level;
772		-
773		- if (!core->vdd_class)
774		- return;
775		-
776		- level = clk_find_vdd_level(core, rate);
777		- if (level < 0)
778		- return;
779		-
780		- clk_unvote_vdd_level(core->vdd_class, level);
781		-}
782		-EXPORT_SYMBOL_GPL(clk_unvote_rate_vdd);
783		-
784		-static bool clk_is_rate_level_valid(struct clk_core *core, unsigned long rate)
785		-{
786		- int level;
787		-
788		- if (!core->vdd_class)
789		- return true;
790		-
791		- level = clk_find_vdd_level(core, rate);
792		-
793		- return level >= 0;
794		-}
795	697
796	698	/* clk api */
797	699
..	..	@@ -901,7 +803,7 @@
901	803	* clk_rate_exclusive_get - get exclusivity over the clk rate control
902	804	* @clk: the clk over which the exclusity of rate control is requested
903	805	*
904		- * clk_rate_exlusive_get() begins a critical section during which a clock
	806	+ * clk_rate_exclusive_get() begins a critical section during which a clock
905	807	* consumer cannot tolerate any other consumer making any operation on the
906	808	* clock which could result in a rate change or rate glitch. Exclusive clocks
907	809	* cannot have their rate changed, either directly or indirectly due to changes
..	..	@@ -957,17 +859,9 @@
957	859	if (core->ops->unprepare)
958	860	core->ops->unprepare(core->hw);
959	861
960		- clk_pm_runtime_put(core);
961		-
962	862	trace_clk_unprepare_complete(core);
963		-
964		- if (core->vdd_class) {
965		- clk_unvote_vdd_level(core->vdd_class, core->vdd_class_vote);
966		- core->vdd_class_vote = 0;
967		- core->new_vdd_class_vote = 0;
968		- }
969		-
970	863	clk_core_unprepare(core->parent);
	864	+ clk_pm_runtime_put(core);
971	865	}
972	866
973	867	static void clk_core_unprepare_lock(struct clk_core *core)
..	..	@@ -1017,28 +911,13 @@
1017	911
1018	912	trace_clk_prepare(core);
1019	913
1020		- ret = clk_vote_rate_vdd(core, core->rate);
1021		- if (ret) {
1022		- clk_core_unprepare(core->parent);
1023		- return ret;
1024		- }
1025		- if (core->vdd_class) {
1026		- core->vdd_class_vote
1027		- = clk_find_vdd_level(core, core->rate);
1028		- core->new_vdd_class_vote = core->vdd_class_vote;
1029		- }
1030		-
1031	914	if (core->ops->prepare)
1032	915	ret = core->ops->prepare(core->hw);
1033	916
1034	917	trace_clk_prepare_complete(core);
1035	918
1036		- if (ret) {
1037		- clk_unvote_rate_vdd(core, core->rate);
1038		- core->vdd_class_vote = 0;
1039		- core->new_vdd_class_vote = 0;
	919	+ if (ret)
1040	920	goto unprepare;
1041		- }
1042	921	}
1043	922
1044	923	core->prepare_count++;
..	..	@@ -1199,6 +1078,101 @@
1199	1078	}
1200	1079
1201	1080	/**
	1081	+ * clk_gate_restore_context - restore context for poweroff
	1082	+ * @hw: the clk_hw pointer of clock whose state is to be restored
	1083	+ *
	1084	+ * The clock gate restore context function enables or disables
	1085	+ * the gate clocks based on the enable_count. This is done in cases
	1086	+ * where the clock context is lost and based on the enable_count
	1087	+ * the clock either needs to be enabled/disabled. This
	1088	+ * helps restore the state of gate clocks.
	1089	+ */
	1090	+void clk_gate_restore_context(struct clk_hw *hw)
	1091	+{
	1092	+ struct clk_core *core = hw->core;
	1093	+
	1094	+ if (core->enable_count)
	1095	+ core->ops->enable(hw);
	1096	+ else
	1097	+ core->ops->disable(hw);
	1098	+}
	1099	+EXPORT_SYMBOL_GPL(clk_gate_restore_context);
	1100	+
	1101	+static int clk_core_save_context(struct clk_core *core)
	1102	+{
	1103	+ struct clk_core *child;
	1104	+ int ret = 0;
	1105	+
	1106	+ hlist_for_each_entry(child, &core->children, child_node) {
	1107	+ ret = clk_core_save_context(child);
	1108	+ if (ret < 0)
	1109	+ return ret;
	1110	+ }
	1111	+
	1112	+ if (core->ops && core->ops->save_context)
	1113	+ ret = core->ops->save_context(core->hw);
	1114	+
	1115	+ return ret;
	1116	+}
	1117	+
	1118	+static void clk_core_restore_context(struct clk_core *core)
	1119	+{
	1120	+ struct clk_core *child;
	1121	+
	1122	+ if (core->ops && core->ops->restore_context)
	1123	+ core->ops->restore_context(core->hw);
	1124	+
	1125	+ hlist_for_each_entry(child, &core->children, child_node)
	1126	+ clk_core_restore_context(child);
	1127	+}
	1128	+
	1129	+/**
	1130	+ * clk_save_context - save clock context for poweroff
	1131	+ *
	1132	+ * Saves the context of the clock register for powerstates in which the
	1133	+ * contents of the registers will be lost. Occurs deep within the suspend
	1134	+ * code. Returns 0 on success.
	1135	+ */
	1136	+int clk_save_context(void)
	1137	+{
	1138	+ struct clk_core *clk;
	1139	+ int ret;
	1140	+
	1141	+ hlist_for_each_entry(clk, &clk_root_list, child_node) {
	1142	+ ret = clk_core_save_context(clk);
	1143	+ if (ret < 0)
	1144	+ return ret;
	1145	+ }
	1146	+
	1147	+ hlist_for_each_entry(clk, &clk_orphan_list, child_node) {
	1148	+ ret = clk_core_save_context(clk);
	1149	+ if (ret < 0)
	1150	+ return ret;
	1151	+ }
	1152	+
	1153	+ return 0;
	1154	+}
	1155	+EXPORT_SYMBOL_GPL(clk_save_context);
	1156	+
	1157	+/**
	1158	+ * clk_restore_context - restore clock context after poweroff
	1159	+ *
	1160	+ * Restore the saved clock context upon resume.
	1161	+ *
	1162	+ */
	1163	+void clk_restore_context(void)
	1164	+{
	1165	+ struct clk_core *core;
	1166	+
	1167	+ hlist_for_each_entry(core, &clk_root_list, child_node)
	1168	+ clk_core_restore_context(core);
	1169	+
	1170	+ hlist_for_each_entry(core, &clk_orphan_list, child_node)
	1171	+ clk_core_restore_context(core);
	1172	+}
	1173	+EXPORT_SYMBOL_GPL(clk_restore_context);
	1174	+
	1175	+/**
1202	1176	* clk_enable - ungate a clock
1203	1177	* @clk: the clk being ungated
1204	1178	*
..	..	@@ -1241,7 +1215,7 @@
1241	1215	clk_core_unprepare_lock(core);
1242	1216	}
1243	1217
1244		-static void clk_unprepare_unused_subtree(struct clk_core *core)
	1218	+static void __init clk_unprepare_unused_subtree(struct clk_core *core)
1245	1219	{
1246	1220	struct clk_core *child;
1247	1221
..	..	@@ -1253,19 +1227,6 @@
1253	1227	if (dev_has_sync_state(core->dev) &&
1254	1228	!(core->flags & CLK_DONT_HOLD_STATE))
1255	1229	return;
1256		-
1257		- /*
1258		- * setting CLK_ENABLE_HAND_OFF flag triggers this conditional
1259		- *
1260		- * need_handoff_prepare implies this clk was already prepared by
1261		- * __clk_init. now we have a proper user, so unset the flag in our
1262		- * internal bookkeeping. See CLK_ENABLE_HAND_OFF flag in clk-provider.h
1263		- * for details.
1264		- */
1265		- if (core->need_handoff_prepare) {
1266		- core->need_handoff_prepare = false;
1267		- clk_core_unprepare(core);
1268		- }
1269	1230
1270	1231	if (core->prepare_count)
1271	1232	return;
..	..	@@ -1288,7 +1249,7 @@
1288	1249	clk_pm_runtime_put(core);
1289	1250	}
1290	1251
1291		-static void clk_disable_unused_subtree(struct clk_core *core)
	1252	+static void __init clk_disable_unused_subtree(struct clk_core *core)
1292	1253	{
1293	1254	struct clk_core *child;
1294	1255	unsigned long flags;
..	..	@@ -1301,21 +1262,6 @@
1301	1262	if (dev_has_sync_state(core->dev) &&
1302	1263	!(core->flags & CLK_DONT_HOLD_STATE))
1303	1264	return;
1304		-
1305		- /*
1306		- * setting CLK_ENABLE_HAND_OFF flag triggers this conditional
1307		- *
1308		- * need_handoff_enable implies this clk was already enabled by
1309		- * __clk_init. now we have a proper user, so unset the flag in our
1310		- * internal bookkeeping. See CLK_ENABLE_HAND_OFF flag in clk-provider.h
1311		- * for details.
1312		- */
1313		- if (core->need_handoff_enable) {
1314		- core->need_handoff_enable = false;
1315		- flags = clk_enable_lock();
1316		- clk_core_disable(core);
1317		- clk_enable_unlock(flags);
1318		- }
1319	1265
1320	1266	if (core->flags & CLK_OPS_PARENT_ENABLE)
1321	1267	clk_core_prepare_enable(core->parent);
..	..	@@ -1353,7 +1299,7 @@
1353	1299	clk_core_disable_unprepare(core->parent);
1354	1300	}
1355	1301
1356		-static bool clk_ignore_unused;
	1302	+static bool clk_ignore_unused __initdata;
1357	1303	static int __init clk_ignore_unused_setup(char *__unused)
1358	1304	{
1359	1305	clk_ignore_unused = true;
..	..	@@ -1361,7 +1307,7 @@
1361	1307	}
1362	1308	__setup("clk_ignore_unused", clk_ignore_unused_setup);
1363	1309
1364		-static int clk_disable_unused(void)
	1310	+static int __init clk_disable_unused(void)
1365	1311	{
1366	1312	struct clk_core *core;
1367	1313
..	..	@@ -1476,10 +1422,7 @@
1476	1422
1477	1423	static bool clk_core_can_round(struct clk_core * const core)
1478	1424	{
1479		- if (core->ops->determine_rate \|\| core->ops->round_rate)
1480		- return true;
1481		-
1482		- return false;
	1425	+ return core->ops->determine_rate \|\| core->ops->round_rate;
1483	1426	}
1484	1427
1485	1428	static int clk_core_round_rate_nolock(struct clk_core *core,
..	..	@@ -1521,6 +1464,21 @@
1521	1464	}
1522	1465	EXPORT_SYMBOL_GPL(__clk_determine_rate);
1523	1466
	1467	+/**
	1468	+ * clk_hw_round_rate() - round the given rate for a hw clk
	1469	+ * @hw: the hw clk for which we are rounding a rate
	1470	+ * @rate: the rate which is to be rounded
	1471	+ *
	1472	+ * Takes in a rate as input and rounds it to a rate that the clk can actually
	1473	+ * use.
	1474	+ *
	1475	+ * Context: prepare_lock must be held.
	1476	+ * For clk providers to call from within clk_ops such as .round_rate,
	1477	+ * .determine_rate.
	1478	+ *
	1479	+ * Return: returns rounded rate of hw clk if clk supports round_rate operation
	1480	+ * else returns the parent rate.
	1481	+ */
1524	1482	unsigned long clk_hw_round_rate(struct clk_hw *hw, unsigned long rate)
1525	1483	{
1526	1484	int ret;
..	..	@@ -1642,18 +1600,12 @@
1642	1600	__clk_recalc_accuracies(child);
1643	1601	}
1644	1602
1645		-static long clk_core_get_accuracy(struct clk_core *core)
	1603	+static long clk_core_get_accuracy_recalc(struct clk_core *core)
1646	1604	{
1647		- unsigned long accuracy;
1648		-
1649		- clk_prepare_lock();
1650	1605	if (core && (core->flags & CLK_GET_ACCURACY_NOCACHE))
1651	1606	__clk_recalc_accuracies(core);
1652	1607
1653		- accuracy = __clk_get_accuracy(core);
1654		- clk_prepare_unlock();
1655		-
1656		- return accuracy;
	1608	+ return clk_core_get_accuracy_no_lock(core);
1657	1609	}
1658	1610
1659	1611	/**
..	..	@@ -1667,10 +1619,16 @@
1667	1619	*/
1668	1620	long clk_get_accuracy(struct clk *clk)
1669	1621	{
	1622	+ long accuracy;
	1623	+
1670	1624	if (!clk)
1671	1625	return 0;
1672	1626
1673		- return clk_core_get_accuracy(clk->core);
	1627	+ clk_prepare_lock();
	1628	+ accuracy = clk_core_get_accuracy_recalc(clk->core);
	1629	+ clk_prepare_unlock();
	1630	+
	1631	+ return accuracy;
1674	1632	}
1675	1633	EXPORT_SYMBOL_GPL(clk_get_accuracy);
1676	1634
..	..	@@ -1724,19 +1682,12 @@
1724	1682	__clk_recalc_rates(child, msg);
1725	1683	}
1726	1684
1727		-static unsigned long clk_core_get_rate(struct clk_core *core)
	1685	+static unsigned long clk_core_get_rate_recalc(struct clk_core *core)
1728	1686	{
1729		- unsigned long rate;
1730		-
1731		- clk_prepare_lock();
1732		-
1733	1687	if (core && (core->flags & CLK_GET_RATE_NOCACHE))
1734	1688	__clk_recalc_rates(core, 0);
1735	1689
1736		- rate = clk_core_get_rate_nolock(core);
1737		- clk_prepare_unlock();
1738		-
1739		- return rate;
	1690	+ return clk_core_get_rate_nolock(core);
1740	1691	}
1741	1692
1742	1693	/**
..	..	@@ -1749,10 +1700,16 @@
1749	1700	*/
1750	1701	unsigned long clk_get_rate(struct clk *clk)
1751	1702	{
	1703	+ unsigned long rate;
	1704	+
1752	1705	if (!clk)
1753	1706	return 0;
1754	1707
1755		- return clk_core_get_rate(clk->core);
	1708	+ clk_prepare_lock();
	1709	+ rate = clk_core_get_rate_recalc(clk->core);
	1710	+ clk_prepare_unlock();
	1711	+
	1712	+ return rate;
1756	1713	}
1757	1714	EXPORT_SYMBOL_GPL(clk_get_rate);
1758	1715
..	..	@@ -1764,12 +1721,58 @@
1764	1721	if (!parent)
1765	1722	return -EINVAL;
1766	1723
1767		- for (i = 0; i < core->num_parents; i++)
1768		- if (clk_core_get_parent_by_index(core, i) == parent)
	1724	+ for (i = 0; i < core->num_parents; i++) {
	1725	+ /* Found it first try! */
	1726	+ if (core->parents[i].core == parent)
1769	1727	return i;
1770	1728
1771		- return -EINVAL;
	1729	+ /* Something else is here, so keep looking */
	1730	+ if (core->parents[i].core)
	1731	+ continue;
	1732	+
	1733	+ /* Maybe core hasn't been cached but the hw is all we know? */
	1734	+ if (core->parents[i].hw) {
	1735	+ if (core->parents[i].hw == parent->hw)
	1736	+ break;
	1737	+
	1738	+ /* Didn't match, but we're expecting a clk_hw */
	1739	+ continue;
	1740	+ }
	1741	+
	1742	+ /* Maybe it hasn't been cached (clk_set_parent() path) */
	1743	+ if (parent == clk_core_get(core, i))
	1744	+ break;
	1745	+
	1746	+ /* Fallback to comparing globally unique names */
	1747	+ if (core->parents[i].name &&
	1748	+ !strcmp(parent->name, core->parents[i].name))
	1749	+ break;
	1750	+ }
	1751	+
	1752	+ if (i == core->num_parents)
	1753	+ return -EINVAL;
	1754	+
	1755	+ core->parents[i].core = parent;
	1756	+ return i;
1772	1757	}
	1758	+
	1759	+/**
	1760	+ * clk_hw_get_parent_index - return the index of the parent clock
	1761	+ * @hw: clk_hw associated with the clk being consumed
	1762	+ *
	1763	+ * Fetches and returns the index of parent clock. Returns -EINVAL if the given
	1764	+ * clock does not have a current parent.
	1765	+ */
	1766	+int clk_hw_get_parent_index(struct clk_hw *hw)
	1767	+{
	1768	+ struct clk_hw *parent = clk_hw_get_parent(hw);
	1769	+
	1770	+ if (WARN_ON(parent == NULL))
	1771	+ return -EINVAL;
	1772	+
	1773	+ return clk_fetch_parent_index(hw->core, parent->core);
	1774	+}
	1775	+EXPORT_SYMBOL_GPL(clk_hw_get_parent_index);
1773	1776
1774	1777	static void clk_core_hold_state(struct clk_core *core)
1775	1778	{
..	..	@@ -1979,59 +1982,12 @@
1979	1982	return ret;
1980	1983	}
1981	1984
1982		-/*
1983		- * Vote for the voltage level required for core->new_rate. Keep track of all
1984		- * clocks with a changed voltage level in clk_rate_change_list.
1985		- */
1986		-static int clk_vote_new_rate_vdd(struct clk_core *core)
1987		-{
1988		- int cur_level, next_level;
1989		- int ret;
1990		-
1991		- if (IS_ERR_OR_NULL(core) \|\| !core->vdd_class)
1992		- return 0;
1993		-
1994		- if (!clk_core_is_prepared(core))
1995		- return 0;
1996		-
1997		- cur_level = core->new_vdd_class_vote;
1998		- next_level = clk_find_vdd_level(core, core->new_rate);
1999		- if (cur_level == next_level)
2000		- return 0;
2001		-
2002		- ret = clk_vote_vdd_level(core->vdd_class, next_level);
2003		- if (ret)
2004		- return ret;
2005		-
2006		- core->new_vdd_class_vote = next_level;
2007		-
2008		- if (list_empty(&core->rate_change_node)) {
2009		- list_add(&core->rate_change_node, &clk_rate_change_list);
2010		- } else {
2011		- /*
2012		- * A different new_rate has been determined for a clock that
2013		- * was already encountered in the clock tree traversal so the
2014		- * level that was previously voted for it should be removed.
2015		- */
2016		- ret = clk_unvote_vdd_level(core->vdd_class, cur_level);
2017		- if (ret)
2018		- return ret;
2019		- }
2020		-
2021		- return 0;
2022		-}
2023		-
2024		-static int clk_calc_subtree(struct clk_core *core, unsigned long new_rate,
	1985	+static void clk_calc_subtree(struct clk_core *core, unsigned long new_rate,
2025	1986	struct clk_core *new_parent, u8 p_index)
2026	1987	{
2027	1988	struct clk_core *child;
2028		- int ret;
2029	1989
2030	1990	core->new_rate = new_rate;
2031		- ret = clk_vote_new_rate_vdd(core);
2032		- if (ret)
2033		- return ret;
2034		-
2035	1991	core->new_parent = new_parent;
2036	1992	core->new_parent_index = p_index;
2037	1993	/* include clk in new parent's PRE_RATE_CHANGE notifications */
..	..	@@ -2041,12 +1997,8 @@
2041	1997
2042	1998	hlist_for_each_entry(child, &core->children, child_node) {
2043	1999	child->new_rate = clk_recalc(child, new_rate);
2044		- ret = clk_calc_subtree(child, child->new_rate, NULL, 0);
2045		- if (ret)
2046		- return ret;
	2000	+ clk_calc_subtree(child, child->new_rate, NULL, 0);
2047	2001	}
2048		-
2049		- return 0;
2050	2002	}
2051	2003
2052	2004	/*
..	..	@@ -2125,23 +2077,12 @@
2125	2077	}
2126	2078	}
2127	2079
2128		- /*
2129		- * Certain PLLs only have 16 bits to program the fractional divider.
2130		- * Hence the programmed rate might be slightly different than the
2131		- * requested one.
2132		- */
2133	2080	if ((core->flags & CLK_SET_RATE_PARENT) && parent &&
2134		- (DIV_ROUND_CLOSEST(best_parent_rate, 1000) !=
2135		- DIV_ROUND_CLOSEST(parent->rate, 1000)))
	2081	+ best_parent_rate != parent->rate)
2136	2082	top = clk_calc_new_rates(parent, best_parent_rate);
2137	2083
2138	2084	out:
2139		- if (!clk_is_rate_level_valid(core, rate))
2140		- return NULL;
2141		-
2142		- ret = clk_calc_subtree(core, new_rate, parent, p_index);
2143		- if (ret)
2144		- return NULL;
	2085	+ clk_calc_subtree(core, new_rate, parent, p_index);
2145	2086
2146	2087	return top;
2147	2088	}
..	..	@@ -2166,6 +2107,13 @@
2166	2107	fail_clk = core;
2167	2108	}
2168	2109
	2110	+ if (core->ops->pre_rate_change) {
	2111	+ ret = core->ops->pre_rate_change(core->hw, core->rate,
	2112	+ core->new_rate);
	2113	+ if (ret)
	2114	+ fail_clk = core;
	2115	+ }
	2116	+
2169	2117	hlist_for_each_entry(child, &core->children, child_node) {
2170	2118	/* Skip children who will be reparented to another clock */
2171	2119	if (child->new_parent && child->new_parent != core)
..	..	@@ -2185,14 +2133,11 @@
2185	2133	return fail_clk;
2186	2134	}
2187	2135
2188		-static int clk_core_set_rate_nolock(struct clk_core *core,
2189		- unsigned long req_rate);
2190		-
2191	2136	/*
2192	2137	* walk down a subtree and set the new rates notifying the rate
2193	2138	* change on the way
2194	2139	*/
2195		-static int clk_change_rate(struct clk_core *core)
	2140	+static void clk_change_rate(struct clk_core *core)
2196	2141	{
2197	2142	struct clk_core *child;
2198	2143	struct hlist_node *tmp;
..	..	@@ -2201,7 +2146,6 @@
2201	2146	bool skip_set_rate = false;
2202	2147	struct clk_core *old_parent;
2203	2148	struct clk_core *parent = NULL;
2204		- int rc = 0;
2205	2149
2206	2150	old_rate = core->rate;
2207	2151
..	..	@@ -2213,9 +2157,8 @@
2213	2157	best_parent_rate = core->parent->rate;
2214	2158	}
2215	2159
2216		- rc = clk_pm_runtime_get(core);
2217		- if (rc)
2218		- return rc;
	2160	+ if (clk_pm_runtime_get(core))
	2161	+ return;
2219	2162
2220	2163	if (core->flags & CLK_SET_RATE_UNGATE) {
2221	2164	unsigned long flags;
..	..	@@ -2225,8 +2168,6 @@
2225	2168	clk_core_enable(core);
2226	2169	clk_enable_unlock(flags);
2227	2170	}
2228		-
2229		- trace_clk_set_rate(core, core->new_rate);
2230	2171
2231	2172	if (core->new_parent && core->new_parent != core->parent) {
2232	2173	old_parent = __clk_set_parent_before(core, core->new_parent);
..	..	@@ -2248,14 +2189,10 @@
2248	2189	if (core->flags & CLK_OPS_PARENT_ENABLE)
2249	2190	clk_core_prepare_enable(parent);
2250	2191
2251		- if (!skip_set_rate && core->ops->set_rate) {
2252		- rc = core->ops->set_rate(core->hw, core->new_rate,
2253		- best_parent_rate);
2254		- if (rc) {
2255		- trace_clk_set_rate_complete(core, core->new_rate);
2256		- goto err_set_rate;
2257		- }
2258		- }
	2192	+ trace_clk_set_rate(core, core->new_rate);
	2193	+
	2194	+ if (!skip_set_rate && core->ops->set_rate)
	2195	+ core->ops->set_rate(core->hw, core->new_rate, best_parent_rate);
2259	2196
2260	2197	trace_clk_set_rate_complete(core, core->new_rate);
2261	2198
..	..	@@ -2279,6 +2216,9 @@
2279	2216	if (core->flags & CLK_RECALC_NEW_RATES)
2280	2217	(void)clk_calc_new_rates(core, core->new_rate);
2281	2218
	2219	+ if (core->ops->post_rate_change)
	2220	+ core->ops->post_rate_change(core->hw, old_rate, core->rate);
	2221	+
2282	2222	/*
2283	2223	* Use safe iteration, as change_rate can actually swap parents
2284	2224	* for certain clock types.
..	..	@@ -2287,24 +2227,14 @@
2287	2227	/* Skip children who will be reparented to another clock */
2288	2228	if (child->new_parent && child->new_parent != core)
2289	2229	continue;
2290		- rc = clk_change_rate(child);
2291		- if (rc)
2292		- goto err_set_rate;
	2230	+ clk_change_rate(child);
2293	2231	}
2294	2232
2295	2233	/* handle the new child who might not be in core->children yet */
2296	2234	if (core->new_child)
2297		- rc = clk_change_rate(core->new_child);
	2235	+ clk_change_rate(core->new_child);
2298	2236
2299		- /* handle a changed clock that needs to readjust its rate */
2300		- if (core->flags & CLK_KEEP_REQ_RATE && core->req_rate
2301		- && core->new_rate != old_rate
2302		- && core->new_rate != core->req_rate)
2303		- clk_core_set_rate_nolock(core, core->req_rate);
2304		-
2305		-err_set_rate:
2306	2237	clk_pm_runtime_put(core);
2307		- return rc;
2308	2238	}
2309	2239
2310	2240	static unsigned long clk_core_req_round_rate_nolock(struct clk_core *core,
..	..	@@ -2334,85 +2264,12 @@
2334	2264	return ret ? 0 : req.rate;
2335	2265	}
2336	2266
2337		-/*
2338		- * Unvote for the voltage level required for each core->new_vdd_class_vote in
2339		- * clk_rate_change_list. This is used when undoing voltage requests after an
2340		- * error is encountered before any physical rate changing.
2341		- */
2342		-static void clk_unvote_new_rate_vdd(void)
2343		-{
2344		- struct clk_core *core;
2345		-
2346		- list_for_each_entry(core, &clk_rate_change_list, rate_change_node) {
2347		- clk_unvote_vdd_level(core->vdd_class, core->new_vdd_class_vote);
2348		- core->new_vdd_class_vote = core->vdd_class_vote;
2349		- }
2350		-}
2351		-
2352		-/*
2353		- * Unvote for the voltage level required for each core->vdd_class_vote in
2354		- * clk_rate_change_list.
2355		- */
2356		-static int clk_unvote_old_rate_vdd(void)
2357		-{
2358		- struct clk_core *core;
2359		- int ret;
2360		-
2361		- list_for_each_entry(core, &clk_rate_change_list, rate_change_node) {
2362		- ret = clk_unvote_vdd_level(core->vdd_class,
2363		- core->vdd_class_vote);
2364		- if (ret)
2365		- return ret;
2366		- }
2367		-
2368		- return 0;
2369		-}
2370		-
2371		-/*
2372		- * In the case that rate setting fails, apply the max voltage level needed
2373		- * by either the old or new rate for each changed clock.
2374		- */
2375		-static void clk_vote_safe_vdd(void)
2376		-{
2377		- struct clk_core *core;
2378		-
2379		- list_for_each_entry(core, &clk_rate_change_list, rate_change_node) {
2380		- if (core->vdd_class_vote > core->new_vdd_class_vote) {
2381		- clk_vote_vdd_level(core->vdd_class,
2382		- core->vdd_class_vote);
2383		- clk_unvote_vdd_level(core->vdd_class,
2384		- core->new_vdd_class_vote);
2385		- core->new_vdd_class_vote = core->vdd_class_vote;
2386		- }
2387		- }
2388		-}
2389		-
2390		-static void clk_cleanup_vdd_votes(void)
2391		-{
2392		- struct clk_core core, temp;
2393		-
2394		- list_for_each_entry_safe(core, temp, &clk_rate_change_list,
2395		- rate_change_node) {
2396		- core->vdd_class_vote = core->new_vdd_class_vote;
2397		- list_del_init(&core->rate_change_node);
2398		- }
2399		-}
2400		-
2401	2267	static int clk_core_set_rate_nolock(struct clk_core *core,
2402	2268	unsigned long req_rate)
2403	2269	{
2404	2270	struct clk_core top, fail_clk;
2405	2271	unsigned long rate;
2406	2272	int ret = 0;
2407		- /*
2408		- * The prepare lock ensures mutual exclusion with other tasks.
2409		- * set_rate_nesting_count is a static so that it can be incremented in
2410		- * the case of reentrancy caused by a set_rate() ops callback itself
2411		- * calling clk_set_rate(). That way, the voltage level votes for the
2412		- * old rates are safely removed when the original invocation of this
2413		- * function completes.
2414		- */
2415		- static unsigned int set_rate_nesting_count;
2416	2273
2417	2274	if (!core)
2418	2275	return 0;
..	..	@@ -2427,63 +2284,31 @@
2427	2284	if (clk_core_rate_is_protected(core))
2428	2285	return -EBUSY;
2429	2286
2430		- set_rate_nesting_count++;
2431		-
2432	2287	/* calculate new rates and get the topmost changed clock */
2433	2288	top = clk_calc_new_rates(core, req_rate);
2434		- if (!top) {
2435		- ret = -EINVAL;
2436		- goto pre_rate_change_err;
2437		- }
	2289	+ if (!top)
	2290	+ return -EINVAL;
2438	2291
2439	2292	ret = clk_pm_runtime_get(core);
2440	2293	if (ret)
2441		- goto pre_rate_change_err;
	2294	+ return ret;
2442	2295
2443	2296	/* notify that we are about to change rates */
2444	2297	fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE);
2445	2298	if (fail_clk) {
2446		- pr_debug("%s: failed to set %s clock to run at %lu\n", __func__,
2447		- fail_clk->name, req_rate);
	2299	+ pr_debug("%s: failed to set %s rate\n", __func__,
	2300	+ fail_clk->name);
2448	2301	clk_propagate_rate_change(top, ABORT_RATE_CHANGE);
2449	2302	ret = -EBUSY;
2450		- clk_pm_runtime_put(core);
2451		- goto pre_rate_change_err;
	2303	+ goto err;
2452	2304	}
2453		-
2454		- core->req_rate = req_rate;
2455	2305
2456	2306	/* change the rates */
2457		- ret = clk_change_rate(top);
2458		- set_rate_nesting_count--;
2459		- if (ret) {
2460		- pr_err("%s: failed to set %s clock to run at %lu\n", __func__,
2461		- top->name, req_rate);
2462		- clk_propagate_rate_change(top, ABORT_RATE_CHANGE);
2463		- clk_vote_safe_vdd();
2464		- goto post_rate_change_err;
2465		- }
	2307	+ clk_change_rate(top);
2466	2308
2467		-post_rate_change_err:
2468		- /*
2469		- * Only remove vdd_class level votes for old clock rates after all
2470		- * nested clk_set_rate() calls have completed.
2471		- */
2472		- if (set_rate_nesting_count == 0) {
2473		- ret \|= clk_unvote_old_rate_vdd();
2474		- clk_cleanup_vdd_votes();
2475		- }
2476		-
	2309	+ core->req_rate = req_rate;
	2310	+err:
2477	2311	clk_pm_runtime_put(core);
2478		-
2479		- return ret;
2480		-
2481		-pre_rate_change_err:
2482		- set_rate_nesting_count--;
2483		- if (set_rate_nesting_count == 0) {
2484		- clk_unvote_new_rate_vdd();
2485		- clk_cleanup_vdd_votes();
2486		- }
2487	2312
2488	2313	return ret;
2489	2314	}
..	..	@@ -2534,7 +2359,7 @@
2534	2359	EXPORT_SYMBOL_GPL(clk_set_rate);
2535	2360
2536	2361	/**
2537		- * clk_set_rate_exclusive - specify a new rate get exclusive control
	2362	+ * clk_set_rate_exclusive - specify a new rate and get exclusive control
2538	2363	* @clk: the clk whose rate is being changed
2539	2364	* @rate: the new rate for clk
2540	2365	*
..	..	@@ -2542,7 +2367,7 @@
2542	2367	* within a critical section
2543	2368	*
2544	2369	* This can be used initially to ensure that at least 1 consumer is
2545		- * statisfied when several consumers are competing for exclusivity over the
	2370	+ * satisfied when several consumers are competing for exclusivity over the
2546	2371	* same clock provider.
2547	2372	*
2548	2373	* The exclusivity is not applied if setting the rate failed.
..	..	@@ -2614,6 +2439,11 @@
2614	2439	clk->min_rate = min;
2615	2440	clk->max_rate = max;
2616	2441
	2442	+ if (!clk_core_check_boundaries(clk->core, min, max)) {
	2443	+ ret = -EINVAL;
	2444	+ goto out;
	2445	+ }
	2446	+
2617	2447	rate = clk_core_get_rate_nolock(clk->core);
2618	2448	if (rate < min \|\| rate > max) {
2619	2449	/*
..	..	@@ -2642,6 +2472,7 @@
2642	2472	}
2643	2473	}
2644	2474
	2475	+out:
2645	2476	if (clk->exclusive_count)
2646	2477	clk_core_rate_protect(clk->core);
2647	2478
..	..	@@ -2744,6 +2575,7 @@
2744	2575	bool clk_has_parent(struct clk clk, struct clk parent)
2745	2576	{
2746	2577	struct clk_core core, parent_core;
	2578	+ int i;
2747	2579
2748	2580	/* NULL clocks should be nops, so return success if either is NULL. */
2749	2581	if (!clk \|\| !parent)
..	..	@@ -2756,8 +2588,11 @@
2756	2588	if (core->parent == parent_core)
2757	2589	return true;
2758	2590
2759		- return match_string(core->parent_names, core->num_parents,
2760		- parent_core->name) >= 0;
	2591	+ for (i = 0; i < core->num_parents; i++)
	2592	+ if (!strcmp(core->parents[i].name, parent_core->name))
	2593	+ return true;
	2594	+
	2595	+ return false;
2761	2596	}
2762	2597	EXPORT_SYMBOL_GPL(clk_has_parent);
2763	2598
..	..	@@ -2773,10 +2608,10 @@
2773	2608	if (!core)
2774	2609	return 0;
2775	2610
2776		- if (core->parent == parent && !(core->flags & CLK_IS_MEASURE))
	2611	+ if (core->parent == parent)
2777	2612	return 0;
2778	2613
2779		- /* verify ops for for multi-parent clks */
	2614	+ /* verify ops for multi-parent clks */
2780	2615	if (core->num_parents > 1 && !core->ops->set_parent)
2781	2616	return -EPERM;
2782	2617
..	..	@@ -2825,6 +2660,12 @@
2825	2660
2826	2661	return ret;
2827	2662	}
	2663	+
	2664	+int clk_hw_set_parent(struct clk_hw hw, struct clk_hw parent)
	2665	+{
	2666	+ return clk_core_set_parent_nolock(hw->core, parent->core);
	2667	+}
	2668	+EXPORT_SYMBOL_GPL(clk_hw_set_parent);
2828	2669
2829	2670	/**
2830	2671	* clk_set_parent - switch the parent of a mux clk
..	..	@@ -2944,12 +2785,14 @@
2944	2785	{
2945	2786	int ret;
2946	2787
2947		- clk_prepare_lock();
	2788	+ lockdep_assert_held(&prepare_lock);
	2789	+ if (!core->ops->get_phase)
	2790	+ return 0;
	2791	+
2948	2792	/* Always try to update cached phase if possible */
2949		- if (core->ops->get_phase)
2950		- core->phase = core->ops->get_phase(core->hw);
2951		- ret = core->phase;
2952		- clk_prepare_unlock();
	2793	+ ret = core->ops->get_phase(core->hw);
	2794	+ if (ret >= 0)
	2795	+ core->phase = ret;
2953	2796
2954	2797	return ret;
2955	2798	}
..	..	@@ -2963,10 +2806,16 @@
2963	2806	*/
2964	2807	int clk_get_phase(struct clk *clk)
2965	2808	{
	2809	+ int ret;
	2810	+
2966	2811	if (!clk)
2967	2812	return 0;
2968	2813
2969		- return clk_core_get_phase(clk->core);
	2814	+ clk_prepare_lock();
	2815	+ ret = clk_core_get_phase(clk->core);
	2816	+ clk_prepare_unlock();
	2817	+
	2818	+ return ret;
2970	2819	}
2971	2820	EXPORT_SYMBOL_GPL(clk_get_phase);
2972	2821
..	..	@@ -3162,26 +3011,9 @@
3162	3011	}
3163	3012	EXPORT_SYMBOL_GPL(clk_is_match);
3164	3013
3165		-int clk_set_flags(struct clk *clk, unsigned long flags)
3166		-{
3167		- if (!clk)
3168		- return 0;
3169		-
3170		- if (!clk->core->ops->set_flags)
3171		- return -EINVAL;
3172		-
3173		- return clk->core->ops->set_flags(clk->core->hw, flags);
3174		-}
3175		-EXPORT_SYMBOL_GPL(clk_set_flags);
3176		-
3177		-void clk_debug_print_hw(struct clk_core clk, struct seq_file f)
3178		-{
3179		-}
3180		-EXPORT_SYMBOL(clk_debug_print_hw);
3181		-
3182	3014	/* debugfs support */
3183	3015
3184		-#ifdef CONFIG_COMMON_CLK_DEBUGFS
	3016	+#ifdef CONFIG_DEBUG_FS
3185	3017	#include <linux/debugfs.h>
3186	3018
3187	3019	static struct dentry *rootdir;
..	..	@@ -3197,25 +3029,28 @@
3197	3029	static void clk_summary_show_one(struct seq_file s, struct clk_core c,
3198	3030	int level)
3199	3031	{
3200		- if (!c)
3201		- return;
	3032	+ int phase;
3202	3033
3203		- seq_printf(s, "%s%-s %7d %8d %8d %11lu %10lu %5d %6d\n",
	3034	+ seq_printf(s, "%s%-s %7d %8d %8d %11lu %10lu ",
3204	3035	level * 3 + 1, "",
3205	3036	30 - level * 3, c->name,
3206	3037	c->enable_count, c->prepare_count, c->protect_count,
3207		- clk_core_get_rate(c), clk_core_get_accuracy(c),
3208		- clk_core_get_phase(c),
3209		- clk_core_get_scaled_duty_cycle(c, 100000));
	3038	+ clk_core_get_rate_recalc(c),
	3039	+ clk_core_get_accuracy_recalc(c));
	3040	+
	3041	+ phase = clk_core_get_phase(c);
	3042	+ if (phase >= 0)
	3043	+ seq_printf(s, "%5d", phase);
	3044	+ else
	3045	+ seq_puts(s, "-----");
	3046	+
	3047	+ seq_printf(s, " %6d\n", clk_core_get_scaled_duty_cycle(c, 100000));
3210	3048	}
3211	3049
3212	3050	static void clk_summary_show_subtree(struct seq_file s, struct clk_core c,
3213	3051	int level)
3214	3052	{
3215	3053	struct clk_core *child;
3216		-
3217		- if (!c)
3218		- return;
3219	3054
3220	3055	clk_summary_show_one(s, c, level);
3221	3056
..	..	@@ -3246,17 +3081,23 @@
3246	3081
3247	3082	static void clk_dump_one(struct seq_file s, struct clk_core c, int level)
3248	3083	{
3249		- if (!c)
3250		- return;
	3084	+ int phase;
	3085	+ unsigned long min_rate, max_rate;
	3086	+
	3087	+ clk_core_get_boundaries(c, &min_rate, &max_rate);
3251	3088
3252	3089	/* This should be JSON format, i.e. elements separated with a comma */
3253	3090	seq_printf(s, "\"%s\": { ", c->name);
3254	3091	seq_printf(s, "\"enable_count\": %d,", c->enable_count);
3255	3092	seq_printf(s, "\"prepare_count\": %d,", c->prepare_count);
3256	3093	seq_printf(s, "\"protect_count\": %d,", c->protect_count);
3257		- seq_printf(s, "\"rate\": %lu,", clk_core_get_rate(c));
3258		- seq_printf(s, "\"accuracy\": %lu,", clk_core_get_accuracy(c));
3259		- seq_printf(s, "\"phase\": %d,", clk_core_get_phase(c));
	3094	+ seq_printf(s, "\"rate\": %lu,", clk_core_get_rate_recalc(c));
	3095	+ seq_printf(s, "\"min_rate\": %lu,", min_rate);
	3096	+ seq_printf(s, "\"max_rate\": %lu,", max_rate);
	3097	+ seq_printf(s, "\"accuracy\": %lu,", clk_core_get_accuracy_recalc(c));
	3098	+ phase = clk_core_get_phase(c);
	3099	+ if (phase >= 0)
	3100	+ seq_printf(s, "\"phase\": %d,", phase);
3260	3101	seq_printf(s, "\"duty_cycle\": %u",
3261	3102	clk_core_get_scaled_duty_cycle(c, 100000));
3262	3103	}
..	..	@@ -3264,9 +3105,6 @@
3264	3105	static void clk_dump_subtree(struct seq_file s, struct clk_core c, int level)
3265	3106	{
3266	3107	struct clk_core *child;
3267		-
3268		- if (!c)
3269		- return;
3270	3108
3271	3109	clk_dump_one(s, c, level);
3272	3110
..	..	@@ -3303,6 +3141,70 @@
3303	3141	}
3304	3142	DEFINE_SHOW_ATTRIBUTE(clk_dump);
3305	3143
	3144	+#ifdef CONFIG_ANDROID_BINDER_IPC
	3145	+#define CLOCK_ALLOW_WRITE_DEBUGFS
	3146	+#else
	3147	+#undef CLOCK_ALLOW_WRITE_DEBUGFS
	3148	+#endif
	3149	+#ifdef CLOCK_ALLOW_WRITE_DEBUGFS
	3150	+/*
	3151	+ * This can be dangerous, therefore don't provide any real compile time
	3152	+ * configuration option for this feature.
	3153	+ * People who want to use this will need to modify the source code directly.
	3154	+ */
	3155	+static int clk_rate_set(void *data, u64 val)
	3156	+{
	3157	+ struct clk_core *core = data;
	3158	+ int ret;
	3159	+
	3160	+ clk_prepare_lock();
	3161	+ ret = clk_core_set_rate_nolock(core, val);
	3162	+ clk_prepare_unlock();
	3163	+
	3164	+ return ret;
	3165	+}
	3166	+
	3167	+#define clk_rate_mode 0644
	3168	+
	3169	+static int clk_prepare_enable_set(void *data, u64 val)
	3170	+{
	3171	+ struct clk_core *core = data;
	3172	+ int ret = 0;
	3173	+
	3174	+ if (val)
	3175	+ ret = clk_prepare_enable(core->hw->clk);
	3176	+ else
	3177	+ clk_disable_unprepare(core->hw->clk);
	3178	+
	3179	+ return ret;
	3180	+}
	3181	+
	3182	+static int clk_prepare_enable_get(void data, u64 val)
	3183	+{
	3184	+ struct clk_core *core = data;
	3185	+
	3186	+ *val = core->enable_count && core->prepare_count;
	3187	+ return 0;
	3188	+}
	3189	+
	3190	+DEFINE_DEBUGFS_ATTRIBUTE(clk_prepare_enable_fops, clk_prepare_enable_get,
	3191	+ clk_prepare_enable_set, "%llu\n");
	3192	+
	3193	+#else
	3194	+#define clk_rate_set NULL
	3195	+#define clk_rate_mode 0444
	3196	+#endif
	3197	+
	3198	+static int clk_rate_get(void data, u64 val)
	3199	+{
	3200	+ struct clk_core *core = data;
	3201	+
	3202	+ *val = core->rate;
	3203	+ return 0;
	3204	+}
	3205	+
	3206	+DEFINE_DEBUGFS_ATTRIBUTE(clk_rate_fops, clk_rate_get, clk_rate_set, "%llu\n");
	3207	+
3306	3208	static const struct {
3307	3209	unsigned long flag;
3308	3210	const char *name;
..	..	@@ -3312,7 +3214,6 @@
3312	3214	ENTRY(CLK_SET_PARENT_GATE),
3313	3215	ENTRY(CLK_SET_RATE_PARENT),
3314	3216	ENTRY(CLK_IGNORE_UNUSED),
3315		- ENTRY(CLK_IS_BASIC),
3316	3217	ENTRY(CLK_GET_RATE_NOCACHE),
3317	3218	ENTRY(CLK_SET_RATE_NO_REPARENT),
3318	3219	ENTRY(CLK_GET_ACCURACY_NOCACHE),
..	..	@@ -3321,8 +3222,6 @@
3321	3222	ENTRY(CLK_IS_CRITICAL),
3322	3223	ENTRY(CLK_OPS_PARENT_ENABLE),
3323	3224	ENTRY(CLK_DUTY_CYCLE_PARENT),
3324		- ENTRY(CLK_DONT_HOLD_STATE),
3325		- ENTRY(CLK_KEEP_REQ_RATE),
3326	3225	#undef ENTRY
3327	3226	};
3328	3227
..	..	@@ -3347,19 +3246,64 @@
3347	3246	}
3348	3247	DEFINE_SHOW_ATTRIBUTE(clk_flags);
3349	3248
	3249	+static void possible_parent_show(struct seq_file s, struct clk_core core,
	3250	+ unsigned int i, char terminator)
	3251	+{
	3252	+ struct clk_core *parent;
	3253	+
	3254	+ /*
	3255	+ * Go through the following options to fetch a parent's name.
	3256	+ *
	3257	+ * 1. Fetch the registered parent clock and use its name
	3258	+ * 2. Use the global (fallback) name if specified
	3259	+ * 3. Use the local fw_name if provided
	3260	+ * 4. Fetch parent clock's clock-output-name if DT index was set
	3261	+ *
	3262	+ * This may still fail in some cases, such as when the parent is
	3263	+ * specified directly via a struct clk_hw pointer, but it isn't
	3264	+ * registered (yet).
	3265	+ */
	3266	+ parent = clk_core_get_parent_by_index(core, i);
	3267	+ if (parent)
	3268	+ seq_puts(s, parent->name);
	3269	+ else if (core->parents[i].name)
	3270	+ seq_puts(s, core->parents[i].name);
	3271	+ else if (core->parents[i].fw_name)
	3272	+ seq_printf(s, "<%s>(fw)", core->parents[i].fw_name);
	3273	+ else if (core->parents[i].index >= 0)
	3274	+ seq_puts(s,
	3275	+ of_clk_get_parent_name(core->of_node,
	3276	+ core->parents[i].index));
	3277	+ else
	3278	+ seq_puts(s, "(missing)");
	3279	+
	3280	+ seq_putc(s, terminator);
	3281	+}
	3282	+
3350	3283	static int possible_parents_show(struct seq_file s, void data)
3351	3284	{
3352	3285	struct clk_core *core = s->private;
3353	3286	int i;
3354	3287
3355	3288	for (i = 0; i < core->num_parents - 1; i++)
3356		- seq_printf(s, "%s ", core->parent_names[i]);
	3289	+ possible_parent_show(s, core, i, ' ');
3357	3290
3358		- seq_printf(s, "%s\n", core->parent_names[i]);
	3291	+ possible_parent_show(s, core, i, '\n');
3359	3292
3360	3293	return 0;
3361	3294	}
3362	3295	DEFINE_SHOW_ATTRIBUTE(possible_parents);
	3296	+
	3297	+static int current_parent_show(struct seq_file s, void data)
	3298	+{
	3299	+ struct clk_core *core = s->private;
	3300	+
	3301	+ if (core->parent)
	3302	+ seq_printf(s, "%s\n", core->parent->name);
	3303	+
	3304	+ return 0;
	3305	+}
	3306	+DEFINE_SHOW_ATTRIBUTE(current_parent);
3363	3307
3364	3308	static int clk_duty_cycle_show(struct seq_file s, void data)
3365	3309	{
..	..	@@ -3372,210 +3316,33 @@
3372	3316	}
3373	3317	DEFINE_SHOW_ATTRIBUTE(clk_duty_cycle);
3374	3318
3375		-static int clock_debug_rate_set(void *data, u64 val)
	3319	+static int clk_min_rate_show(struct seq_file s, void data)
3376	3320	{
3377		- struct clk_core *core = data;
3378		- int ret;
	3321	+ struct clk_core *core = s->private;
	3322	+ unsigned long min_rate, max_rate;
3379	3323
3380		- ret = clk_set_rate(core->hw->clk, val);
3381		- if (ret)
3382		- pr_err("clk_set_rate(%lu) failed (%d)\n",
3383		- (unsigned long)val, ret);
3384		-
3385		- return ret;
3386		-}
3387		-
3388		-static int clock_debug_rate_get(void data, u64 val)
3389		-{
3390		- struct clk_core *core = data;
3391		-
3392		- *val = core->hw->core->rate;
	3324	+ clk_prepare_lock();
	3325	+ clk_core_get_boundaries(core, &min_rate, &max_rate);
	3326	+ clk_prepare_unlock();
	3327	+ seq_printf(s, "%lu\n", min_rate);
3393	3328
3394	3329	return 0;
3395	3330	}
	3331	+DEFINE_SHOW_ATTRIBUTE(clk_min_rate);
3396	3332
3397		-DEFINE_SIMPLE_ATTRIBUTE(clock_rate_fops, clock_debug_rate_get,
3398		- clock_debug_rate_set, "%llu\n");
3399		-
3400		-static int clock_available_parent_show(struct seq_file s, void data)
	3333	+static int clk_max_rate_show(struct seq_file s, void data)
3401	3334	{
3402		- struct clk_core core = (struct clk_core )s->private;
3403		- int i;
	3335	+ struct clk_core *core = s->private;
	3336	+ unsigned long min_rate, max_rate;
3404	3337
3405		- for (i = 0; i < core->num_parents; i++) {
3406		- if (!core->parents[i])
3407		- continue;
3408		- seq_printf(s, "%s ", core->parents[i]->name);
3409		- }
3410		- seq_puts(s, "\n");
	3338	+ clk_prepare_lock();
	3339	+ clk_core_get_boundaries(core, &min_rate, &max_rate);
	3340	+ clk_prepare_unlock();
	3341	+ seq_printf(s, "%lu\n", max_rate);
3411	3342
3412	3343	return 0;
3413	3344	}
3414		-
3415		-static int clock_available_parent_open(struct inode inode, struct file file)
3416		-{
3417		- return single_open(file, clock_available_parent_show, inode->i_private);
3418		-}
3419		-
3420		-static const struct file_operations clock_available_parent_fops = {
3421		- .open = clock_available_parent_open,
3422		- .read = seq_read,
3423		- .llseek = seq_lseek,
3424		- .release = single_release,
3425		-};
3426		-
3427		-static ssize_t clock_parent_read(struct file filp, char __user ubuf,
3428		- size_t cnt, loff_t *ppos)
3429		-{
3430		- char name[256] = {0};
3431		- struct clk_core *core = filp->private_data;
3432		- struct clk_core *p = core->parent;
3433		-
3434		- snprintf(name, sizeof(name), "%s\n", p ? p->name : "None\n");
3435		-
3436		- return simple_read_from_buffer(ubuf, cnt, ppos, name, strlen(name));
3437		-}
3438		-
3439		-static ssize_t clock_parent_write(struct file filp, const char __user buf,
3440		- size_t cnt, loff_t *ppos)
3441		-{
3442		- char temp[256] = {0};
3443		- char name[256] = {0};
3444		- struct clk_core *core = filp->private_data;
3445		- unsigned int ret, i;
3446		-
3447		- if (copy_from_user(temp, buf, cnt))
3448		- return -EINVAL;
3449		-
3450		- ret = sscanf(temp, "%s", name);
3451		- if (ret != 1)
3452		- return -EINVAL;
3453		-
3454		- for (i = 0; i < core->num_parents; i++) {
3455		- if (!core->parents[i])
3456		- continue;
3457		- if (!strcmp(core->parents[i]->name, name)) {
3458		- if (core->parents[i] != core->parent)
3459		- clk_core_set_parent_nolock(core,
3460		- core->parents[i]);
3461		- break;
3462		- }
3463		- }
3464		-
3465		- return cnt;
3466		-}
3467		-
3468		-static const struct file_operations clock_parent_fops = {
3469		- .open = simple_open,
3470		- .read = clock_parent_read,
3471		- .write = clock_parent_write,
3472		-};
3473		-
3474		-static int clock_debug_enable_set(void *data, u64 val)
3475		-{
3476		- struct clk_core *core = data;
3477		- int rc = 0;
3478		-
3479		- if (val)
3480		- rc = clk_prepare_enable(core->hw->clk);
3481		- else
3482		- clk_disable_unprepare(core->hw->clk);
3483		-
3484		- return rc;
3485		-}
3486		-
3487		-static int clock_debug_enable_get(void data, u64 val)
3488		-{
3489		- struct clk_core *core = data;
3490		- int enabled = 0;
3491		-
3492		- enabled = core->enable_count;
3493		-
3494		- *val = enabled;
3495		-
3496		- return 0;
3497		-}
3498		-
3499		-DEFINE_DEBUGFS_ATTRIBUTE(clock_enable_fops, clock_debug_enable_get,
3500		- clock_debug_enable_set, "%lld\n");
3501		-
3502		-#define clock_debug_output(m, c, fmt, ...) \
3503		-do { \
3504		- if (m) \
3505		- seq_printf(m, fmt, ##__VA_ARGS__); \
3506		- else if (c) \
3507		- pr_cont(fmt, ##__VA_ARGS__); \
3508		- else \
3509		- pr_info(fmt, ##__VA_ARGS__); \
3510		-} while (0)
3511		-
3512		-static int clock_debug_print_clock(struct clk_core c, struct seq_file s)
3513		-{
3514		- char *start = "";
3515		- struct clk *clk;
3516		-
3517		- if (!c \|\| !c->prepare_count)
3518		- return 0;
3519		-
3520		- clk = c->hw->clk;
3521		-
3522		- clock_debug_output(s, 0, "\t");
3523		-
3524		- do {
3525		- clock_debug_output(s, 1, "%s%s:%u:%u [%ld]", start,
3526		- clk->core->name,
3527		- clk->core->prepare_count,
3528		- clk->core->enable_count,
3529		- clk->core->rate);
3530		- start = " -> ";
3531		- } while ((clk = clk_get_parent(clk)));
3532		-
3533		- clock_debug_output(s, 1, "\n");
3534		-
3535		- return 1;
3536		-}
3537		-
3538		-/*
3539		- * clock_debug_print_enabled_clocks() - Print names of enabled clocks
3540		- */
3541		-static void clock_debug_print_enabled_clocks(struct seq_file *s)
3542		-{
3543		- struct clk_core *core;
3544		- int cnt = 0;
3545		-
3546		- clock_debug_output(s, 0, "Enabled clocks:\n");
3547		-
3548		- mutex_lock(&clk_debug_lock);
3549		-
3550		- hlist_for_each_entry(core, &clk_debug_list, debug_node)
3551		- cnt += clock_debug_print_clock(core, s);
3552		-
3553		- mutex_unlock(&clk_debug_lock);
3554		-
3555		- if (cnt)
3556		- clock_debug_output(s, 0, "Enabled clock count: %d\n", cnt);
3557		- else
3558		- clock_debug_output(s, 0, "No clocks enabled.\n");
3559		-}
3560		-
3561		-static int enabled_clocks_show(struct seq_file s, void unused)
3562		-{
3563		- clock_debug_print_enabled_clocks(s);
3564		-
3565		- return 0;
3566		-}
3567		-
3568		-static int enabled_clocks_open(struct inode inode, struct file file)
3569		-{
3570		- return single_open(file, enabled_clocks_show, inode->i_private);
3571		-}
3572		-
3573		-static const struct file_operations clk_enabled_list_fops = {
3574		- .open = enabled_clocks_open,
3575		- .read = seq_read,
3576		- .llseek = seq_lseek,
3577		- .release = seq_release,
3578		-};
	3345	+DEFINE_SHOW_ATTRIBUTE(clk_max_rate);
3579	3346
3580	3347	static void clk_debug_create_one(struct clk_core core, struct dentry pdentry)
3581	3348	{
..	..	@@ -3587,22 +3354,27 @@
3587	3354	root = debugfs_create_dir(core->name, pdentry);
3588	3355	core->dentry = root;
3589	3356
3590		- debugfs_create_file("clk_rate", 0444, root, core,
3591		- &clock_rate_fops);
	3357	+ debugfs_create_file("clk_rate", clk_rate_mode, root, core,
	3358	+ &clk_rate_fops);
	3359	+ debugfs_create_file("clk_min_rate", 0444, root, core, &clk_min_rate_fops);
	3360	+ debugfs_create_file("clk_max_rate", 0444, root, core, &clk_max_rate_fops);
3592	3361	debugfs_create_ulong("clk_accuracy", 0444, root, &core->accuracy);
3593	3362	debugfs_create_u32("clk_phase", 0444, root, &core->phase);
3594	3363	debugfs_create_file("clk_flags", 0444, root, core, &clk_flags_fops);
3595	3364	debugfs_create_u32("clk_prepare_count", 0444, root, &core->prepare_count);
3596		- debugfs_create_file("clk_enable_count", 0444, root, core,
3597		- &clock_enable_fops);
	3365	+ debugfs_create_u32("clk_enable_count", 0444, root, &core->enable_count);
3598	3366	debugfs_create_u32("clk_protect_count", 0444, root, &core->protect_count);
3599	3367	debugfs_create_u32("clk_notifier_count", 0444, root, &core->notifier_count);
3600	3368	debugfs_create_file("clk_duty_cycle", 0444, root, core,
3601	3369	&clk_duty_cycle_fops);
3602		- debugfs_create_file("clk_available_parent", 0444, root, core,
3603		- &clock_available_parent_fops);
3604		- debugfs_create_file("clk_parent", 0444, root, core,
3605		- &clock_parent_fops);
	3370	+#ifdef CLOCK_ALLOW_WRITE_DEBUGFS
	3371	+ debugfs_create_file("clk_prepare_enable", 0644, root, core,
	3372	+ &clk_prepare_enable_fops);
	3373	+#endif
	3374	+
	3375	+ if (core->num_parents > 0)
	3376	+ debugfs_create_file("clk_parent", 0444, root, core,
	3377	+ &current_parent_fops);
3606	3378
3607	3379	if (core->num_parents > 1)
3608	3380	debugfs_create_file("clk_possible_parents", 0444, root, core,
..	..	@@ -3659,6 +3431,24 @@
3659	3431	{
3660	3432	struct clk_core *core;
3661	3433
	3434	+#ifdef CLOCK_ALLOW_WRITE_DEBUGFS
	3435	+ pr_warn("\n");
	3436	+ pr_warn("********************************************************************\n");
	3437	+ pr_warn(" NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE \n");
	3438	+ pr_warn(" \n");
	3439	+ pr_warn(" WRITEABLE clk DebugFS SUPPORT HAS BEEN ENABLED IN THIS KERNEL \n");
	3440	+ pr_warn(" \n");
	3441	+ pr_warn(" This means that this kernel is built to expose clk operations \n");
	3442	+ pr_warn(" such as parent or rate setting, enabling, disabling, etc. \n");
	3443	+ pr_warn(" to userspace, which may compromise security on your system. \n");
	3444	+ pr_warn(" \n");
	3445	+ pr_warn(" If you see this message and you are not debugging the \n");
	3446	+ pr_warn(" kernel, report this immediately to your vendor! \n");
	3447	+ pr_warn(" \n");
	3448	+ pr_warn(" NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE \n");
	3449	+ pr_warn("********************************************************************\n");
	3450	+#endif
	3451	+
3662	3452	rootdir = debugfs_create_dir("clk", NULL);
3663	3453
3664	3454	debugfs_create_file("clk_summary", 0444, rootdir, &all_lists,
..	..	@@ -3669,9 +3459,6 @@
3669	3459	&clk_summary_fops);
3670	3460	debugfs_create_file("clk_orphan_dump", 0444, rootdir, &orphan_list,
3671	3461	&clk_dump_fops);
3672		-
3673		- debugfs_create_file("clk_enabled_list", 0444, rootdir,
3674		- &clk_debug_list, &clk_enabled_list_fops);
3675	3462
3676	3463	mutex_lock(&clk_debug_lock);
3677	3464	hlist_for_each_entry(core, &clk_debug_list, debug_node)
..	..	@@ -3685,14 +3472,52 @@
3685	3472	late_initcall(clk_debug_init);
3686	3473	#else
3687	3474	static inline void clk_debug_register(struct clk_core *core) { }
3688		-static inline void clk_debug_reparent(struct clk_core *core,
3689		- struct clk_core *new_parent)
3690		-{
3691		-}
3692	3475	static inline void clk_debug_unregister(struct clk_core *core)
3693	3476	{
3694	3477	}
3695	3478	#endif
	3479	+
	3480	+static void clk_core_reparent_orphans_nolock(void)
	3481	+{
	3482	+ struct clk_core *orphan;
	3483	+ struct hlist_node *tmp2;
	3484	+
	3485	+ /*
	3486	+ * walk the list of orphan clocks and reparent any that newly finds a
	3487	+ * parent.
	3488	+ */
	3489	+ hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) {
	3490	+ struct clk_core *parent = __clk_init_parent(orphan);
	3491	+
	3492	+ /*
	3493	+ * We need to use __clk_set_parent_before() and _after() to
	3494	+ * to properly migrate any prepare/enable count of the orphan
	3495	+ * clock. This is important for CLK_IS_CRITICAL clocks, which
	3496	+ * are enabled during init but might not have a parent yet.
	3497	+ */
	3498	+ if (parent) {
	3499	+ /* update the clk tree topology */
	3500	+ __clk_set_parent_before(orphan, parent);
	3501	+ __clk_set_parent_after(orphan, parent, NULL);
	3502	+ __clk_recalc_accuracies(orphan);
	3503	+ __clk_recalc_rates(orphan, 0);
	3504	+ __clk_core_update_orphan_hold_state(orphan);
	3505	+
	3506	+ /*
	3507	+ * __clk_init_parent() will set the initial req_rate to
	3508	+ * 0 if the clock doesn't have clk_ops::recalc_rate and
	3509	+ * is an orphan when it's registered.
	3510	+ *
	3511	+ * 'req_rate' is used by clk_set_rate_range() and
	3512	+ * clk_put() to trigger a clk_set_rate() call whenever
	3513	+ * the boundaries are modified. Let's make sure
	3514	+ * 'req_rate' is set to something non-zero so that
	3515	+ * clk_set_rate_range() doesn't drop the frequency.
	3516	+ */
	3517	+ orphan->req_rate = orphan->rate;
	3518	+ }
	3519	+ }
	3520	+}
3696	3521
3697	3522	/**
3698	3523	* __clk_core_init - initialize the data structures in a struct clk_core
..	..	@@ -3703,15 +3528,23 @@
3703	3528	*/
3704	3529	static int __clk_core_init(struct clk_core *core)
3705	3530	{
3706		- int i, ret;
3707		- struct clk_core *orphan;
3708		- struct hlist_node *tmp2;
	3531	+ int ret;
	3532	+ struct clk_core *parent;
3709	3533	unsigned long rate;
	3534	+ int phase;
3710	3535
3711	3536	if (!core)
3712	3537	return -EINVAL;
3713	3538
3714	3539	clk_prepare_lock();
	3540	+
	3541	+ /*
	3542	+ * Set hw->core after grabbing the prepare_lock to synchronize with
	3543	+ * callers of clk_core_fill_parent_index() where we treat hw->core
	3544	+ * being NULL as the clk not being registered yet. This is crucial so
	3545	+ * that clks aren't parented until their parent is fully registered.
	3546	+ */
	3547	+ core->hw->core = core;
3715	3548
3716	3549	ret = clk_pm_runtime_get(core);
3717	3550	if (ret)
..	..	@@ -3757,13 +3590,27 @@
3757	3590	goto out;
3758	3591	}
3759	3592
3760		- /* throw a WARN if any entries in parent_names are NULL */
3761		- for (i = 0; i < core->num_parents; i++)
3762		- WARN(!core->parent_names[i],
3763		- "%s: invalid NULL in %s's .parent_names\n",
3764		- __func__, core->name);
	3593	+ /*
	3594	+ * optional platform-specific magic
	3595	+ *
	3596	+ * The .init callback is not used by any of the basic clock types, but
	3597	+ * exists for weird hardware that must perform initialization magic for
	3598	+ * CCF to get an accurate view of clock for any other callbacks. It may
	3599	+ * also be used needs to perform dynamic allocations. Such allocation
	3600	+ * must be freed in the terminate() callback.
	3601	+ * This callback shall not be used to initialize the parameters state,
	3602	+ * such as rate, parent, etc ...
	3603	+ *
	3604	+ * If it exist, this callback should called before any other callback of
	3605	+ * the clock
	3606	+ */
	3607	+ if (core->ops->init) {
	3608	+ ret = core->ops->init(core->hw);
	3609	+ if (ret)
	3610	+ goto out;
	3611	+ }
3765	3612
3766		- core->parent = __clk_init_parent(core);
	3613	+ parent = core->parent = __clk_init_parent(core);
3767	3614
3768	3615	/*
3769	3616	* Populate core->parent if parent has already been clk_core_init'd. If
..	..	@@ -3775,10 +3622,9 @@
3775	3622	* clocks and re-parent any that are children of the clock currently
3776	3623	* being clk_init'd.
3777	3624	*/
3778		- if (core->parent) {
3779		- hlist_add_head(&core->child_node,
3780		- &core->parent->children);
3781		- core->orphan = core->parent->orphan;
	3625	+ if (parent) {
	3626	+ hlist_add_head(&core->child_node, &parent->children);
	3627	+ core->orphan = parent->orphan;
3782	3628	} else if (!core->num_parents) {
3783	3629	hlist_add_head(&core->child_node, &clk_root_list);
3784	3630	core->orphan = false;
..	..	@@ -3786,17 +3632,6 @@
3786	3632	hlist_add_head(&core->child_node, &clk_orphan_list);
3787	3633	core->orphan = true;
3788	3634	}
3789		-
3790		- /*
3791		- * optional platform-specific magic
3792		- *
3793		- * The .init callback is not used by any of the basic clock types, but
3794		- * exists for weird hardware that must perform initialization magic.
3795		- * Please consider other ways of solving initialization problems before
3796		- * using this callback, as its use is discouraged.
3797		- */
3798		- if (core->ops->init)
3799		- core->ops->init(core->hw);
3800	3635
3801	3636	/*
3802	3637	* Set clk's accuracy. The preferred method is to use
..	..	@@ -3807,21 +3642,24 @@
3807	3642	*/
3808	3643	if (core->ops->recalc_accuracy)
3809	3644	core->accuracy = core->ops->recalc_accuracy(core->hw,
3810		- __clk_get_accuracy(core->parent));
3811		- else if (core->parent)
3812		- core->accuracy = core->parent->accuracy;
	3645	+ clk_core_get_accuracy_no_lock(parent));
	3646	+ else if (parent)
	3647	+ core->accuracy = parent->accuracy;
3813	3648	else
3814	3649	core->accuracy = 0;
3815	3650
3816	3651	/*
3817		- * Set clk's phase.
	3652	+ * Set clk's phase by clk_core_get_phase() caching the phase.
3818	3653	* Since a phase is by definition relative to its parent, just
3819	3654	* query the current clock phase, or just assume it's in phase.
3820	3655	*/
3821		- if (core->ops->get_phase)
3822		- core->phase = core->ops->get_phase(core->hw);
3823		- else
3824		- core->phase = 0;
	3656	+ phase = clk_core_get_phase(core);
	3657	+ if (phase < 0) {
	3658	+ ret = phase;
	3659	+ pr_warn("%s: Failed to get phase for clk '%s'\n", __func__,
	3660	+ core->name);
	3661	+ goto out;
	3662	+ }
3825	3663
3826	3664	/*
3827	3665	* Set clk's duty cycle.
..	..	@@ -3836,9 +3674,9 @@
3836	3674	*/
3837	3675	if (core->ops->recalc_rate)
3838	3676	rate = core->ops->recalc_rate(core->hw,
3839		- clk_core_get_rate_nolock(core->parent));
3840		- else if (core->parent)
3841		- rate = core->parent->rate;
	3677	+ clk_core_get_rate_nolock(parent));
	3678	+ else if (parent)
	3679	+ rate = parent->rate;
3842	3680	else
3843	3681	rate = 0;
3844	3682	core->rate = core->req_rate = rate;
..	..	@@ -3853,96 +3691,36 @@
3853	3691	if (core->flags & CLK_IS_CRITICAL) {
3854	3692	unsigned long flags;
3855	3693
3856		- clk_core_prepare(core);
	3694	+ ret = clk_core_prepare(core);
	3695	+ if (ret) {
	3696	+ pr_warn("%s: critical clk '%s' failed to prepare\n",
	3697	+ __func__, core->name);
	3698	+ goto out;
	3699	+ }
3857	3700
3858	3701	flags = clk_enable_lock();
3859		- clk_core_enable(core);
	3702	+ ret = clk_core_enable(core);
3860	3703	clk_enable_unlock(flags);
	3704	+ if (ret) {
	3705	+ pr_warn("%s: critical clk '%s' failed to enable\n",
	3706	+ __func__, core->name);
	3707	+ clk_core_unprepare(core);
	3708	+ goto out;
	3709	+ }
3861	3710	}
3862	3711
3863	3712	clk_core_hold_state(core);
	3713	+ clk_core_reparent_orphans_nolock();
3864	3714
3865		- /*
3866		- * walk the list of orphan clocks and reparent any that newly finds a
3867		- * parent.
3868		- */
3869		- hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) {
3870		- struct clk_core *parent = __clk_init_parent(orphan);
3871		-
3872		- /*
3873		- * We need to use __clk_set_parent_before() and _after() to
3874		- * to properly migrate any prepare/enable count of the orphan
3875		- * clock. This is important for CLK_IS_CRITICAL clocks, which
3876		- * are enabled during init but might not have a parent yet.
3877		- */
3878		- if (parent) {
3879		- /* update the clk tree topology */
3880		- __clk_set_parent_before(orphan, parent);
3881		- __clk_set_parent_after(orphan, parent, NULL);
3882		- __clk_recalc_accuracies(orphan);
3883		- __clk_recalc_rates(orphan, 0);
3884		- __clk_core_update_orphan_hold_state(orphan);
3885		- }
3886		- }
3887		-
3888		- /*
3889		- * optional platform-specific magic
3890		- *
3891		- * The .init callback is not used by any of the basic clock types, but
3892		- * exists for weird hardware that must perform initialization magic.
3893		- * Please consider other ways of solving initialization problems before
3894		- * using this callback, as its use is discouraged.
3895		- */
3896		- if (core->ops->init)
3897		- core->ops->init(core->hw);
3898		-
3899		- if (core->flags & CLK_IS_CRITICAL) {
3900		- unsigned long flags;
3901		-
3902		- clk_core_prepare(core);
3903		-
3904		- flags = clk_enable_lock();
3905		- clk_core_enable(core);
3906		- clk_enable_unlock(flags);
3907		- }
3908		-
3909		- /*
3910		- * enable clocks with the CLK_ENABLE_HAND_OFF flag set
3911		- *
3912		- * This flag causes the framework to enable the clock at registration
3913		- * time, which is sometimes necessary for clocks that would cause a
3914		- * system crash when gated (e.g. cpu, memory, etc). The prepare_count
3915		- * is migrated over to the first clk consumer to call clk_prepare().
3916		- * Similarly the clk's enable_count is migrated to the first consumer
3917		- * to call clk_enable().
3918		- */
3919		- if (core->flags & CLK_ENABLE_HAND_OFF) {
3920		- unsigned long flags;
3921		-
3922		- /*
3923		- * Few clocks might have hardware gating which would be
3924		- * required to be ON before prepare/enabling the clocks. So
3925		- * check if the clock has been turned ON earlier and we should
3926		- * prepare/enable those clocks.
3927		- */
3928		- if (clk_core_is_enabled(core)) {
3929		- core->need_handoff_prepare = true;
3930		- core->need_handoff_enable = true;
3931		- ret = clk_core_prepare(core);
3932		- if (ret)
3933		- goto out;
3934		- flags = clk_enable_lock();
3935		- clk_core_enable(core);
3936		- clk_enable_unlock(flags);
3937		- }
3938		- }
3939	3715
3940	3716	kref_init(&core->ref);
3941	3717	out:
3942	3718	clk_pm_runtime_put(core);
3943	3719	unlock:
3944		- if (ret)
	3720	+ if (ret) {
3945	3721	hlist_del_init(&core->child_node);
	3722	+ core->hw->core = NULL;
	3723	+ }
3946	3724
3947	3725	clk_prepare_unlock();
3948	3726
..	..	@@ -3952,8 +3730,38 @@
3952	3730	return ret;
3953	3731	}
3954	3732
3955		-static struct clk clk_hw_create_clk(struct clk_hw hw, const char *dev_id,
3956		- const char *con_id)
	3733	+/**
	3734	+ * clk_core_link_consumer - Add a clk consumer to the list of consumers in a clk_core
	3735	+ * @core: clk to add consumer to
	3736	+ * @clk: consumer to link to a clk
	3737	+ */
	3738	+static void clk_core_link_consumer(struct clk_core core, struct clk clk)
	3739	+{
	3740	+ clk_prepare_lock();
	3741	+ hlist_add_head(&clk->clks_node, &core->clks);
	3742	+ clk_prepare_unlock();
	3743	+}
	3744	+
	3745	+/**
	3746	+ * clk_core_unlink_consumer - Remove a clk consumer from the list of consumers in a clk_core
	3747	+ * @clk: consumer to unlink
	3748	+ */
	3749	+static void clk_core_unlink_consumer(struct clk *clk)
	3750	+{
	3751	+ lockdep_assert_held(&prepare_lock);
	3752	+ hlist_del(&clk->clks_node);
	3753	+}
	3754	+
	3755	+/**
	3756	+ * alloc_clk - Allocate a clk consumer, but leave it unlinked to the clk_core
	3757	+ * @core: clk to allocate a consumer for
	3758	+ * @dev_id: string describing device name
	3759	+ * @con_id: connection ID string on device
	3760	+ *
	3761	+ * Returns: clk consumer left unlinked from the consumer list
	3762	+ */
	3763	+static struct clk alloc_clk(struct clk_core core, const char *dev_id,
	3764	+ const char *con_id)
3957	3765	{
3958	3766	struct clk *clk;
3959	3767
..	..	@@ -3961,56 +3769,192 @@
3961	3769	if (!clk)
3962	3770	return ERR_PTR(-ENOMEM);
3963	3771
3964		- clk->core = hw->core;
	3772	+ clk->core = core;
3965	3773	clk->dev_id = dev_id;
3966	3774	clk->con_id = kstrdup_const(con_id, GFP_KERNEL);
3967	3775	clk->max_rate = ULONG_MAX;
3968	3776
3969		- clk_prepare_lock();
3970		- hlist_add_head(&clk->clks_node, &hw->core->clks);
3971		- clk_prepare_unlock();
3972		-
3973	3777	return clk;
3974	3778	}
3975	3779
3976		-struct clk __clk_create_clk(struct clk_hw hw, const char *dev_id,
3977		- const char *con_id, bool with_orphans)
	3780	+/**
	3781	+ * free_clk - Free a clk consumer
	3782	+ * @clk: clk consumer to free
	3783	+ *
	3784	+ * Note, this assumes the clk has been unlinked from the clk_core consumer
	3785	+ * list.
	3786	+ */
	3787	+static void free_clk(struct clk *clk)
3978	3788	{
3979		- /* This is to allow this function to be chained to others */
3980		- if (!hw \|\| IS_ERR(hw))
3981		- return (struct clk *) hw;
3982		-
3983		- if (hw->core->orphan && !with_orphans)
3984		- return ERR_PTR(-EPROBE_DEFER);
3985		-
3986		- return clk_hw_create_clk(hw, dev_id, con_id);
3987		-}
3988		-
3989		-void __clk_free_clk(struct clk *clk)
3990		-{
3991		- clk_prepare_lock();
3992		- hlist_del(&clk->clks_node);
3993		- clk_prepare_unlock();
3994		-
3995	3789	kfree_const(clk->con_id);
3996	3790	kfree(clk);
3997	3791	}
3998	3792
3999	3793	/**
4000		- * clk_register - allocate a new clock, register it and return an opaque cookie
4001		- * @dev: device that is registering this clock
4002		- * @hw: link to hardware-specific clock data
	3794	+ * clk_hw_create_clk: Allocate and link a clk consumer to a clk_core given
	3795	+ * a clk_hw
	3796	+ * @dev: clk consumer device
	3797	+ * @hw: clk_hw associated with the clk being consumed
	3798	+ * @dev_id: string describing device name
	3799	+ * @con_id: connection ID string on device
4003	3800	*
4004		- * clk_register is the primary interface for populating the clock tree with new
4005		- * clock nodes. It returns a pointer to the newly allocated struct clk which
4006		- * cannot be dereferenced by driver code but may be used in conjunction with the
4007		- * rest of the clock API. In the event of an error clk_register will return an
4008		- * error code; drivers must test for an error code after calling clk_register.
	3801	+ * This is the main function used to create a clk pointer for use by clk
	3802	+ * consumers. It connects a consumer to the clk_core and clk_hw structures
	3803	+ * used by the framework and clk provider respectively.
4009	3804	*/
4010		-struct clk clk_register(struct device dev, struct clk_hw *hw)
	3805	+struct clk clk_hw_create_clk(struct device dev, struct clk_hw *hw,
	3806	+ const char dev_id, const char con_id)
4011	3807	{
4012		- int i, ret;
	3808	+ struct clk *clk;
4013	3809	struct clk_core *core;
	3810	+
	3811	+ /* This is to allow this function to be chained to others */
	3812	+ if (IS_ERR_OR_NULL(hw))
	3813	+ return ERR_CAST(hw);
	3814	+
	3815	+ core = hw->core;
	3816	+ clk = alloc_clk(core, dev_id, con_id);
	3817	+ if (IS_ERR(clk))
	3818	+ return clk;
	3819	+ clk->dev = dev;
	3820	+
	3821	+ if (!try_module_get(core->owner)) {
	3822	+ free_clk(clk);
	3823	+ return ERR_PTR(-ENOENT);
	3824	+ }
	3825	+
	3826	+ kref_get(&core->ref);
	3827	+ clk_core_link_consumer(core, clk);
	3828	+
	3829	+ return clk;
	3830	+}
	3831	+
	3832	+/**
	3833	+ * clk_hw_get_clk - get clk consumer given an clk_hw
	3834	+ * @hw: clk_hw associated with the clk being consumed
	3835	+ * @con_id: connection ID string on device
	3836	+ *
	3837	+ * Returns: new clk consumer
	3838	+ * This is the function to be used by providers which need
	3839	+ * to get a consumer clk and act on the clock element
	3840	+ * Calls to this function must be balanced with calls clk_put()
	3841	+ */
	3842	+struct clk clk_hw_get_clk(struct clk_hw hw, const char *con_id)
	3843	+{
	3844	+ struct device *dev = hw->core->dev;
	3845	+ const char *name = dev ? dev_name(dev) : NULL;
	3846	+
	3847	+ return clk_hw_create_clk(dev, hw, name, con_id);
	3848	+}
	3849	+EXPORT_SYMBOL(clk_hw_get_clk);
	3850	+
	3851	+static int clk_cpy_name(const char *dst_p, const char src, bool must_exist)
	3852	+{
	3853	+ const char *dst;
	3854	+
	3855	+ if (!src) {
	3856	+ if (must_exist)
	3857	+ return -EINVAL;
	3858	+ return 0;
	3859	+ }
	3860	+
	3861	+ *dst_p = dst = kstrdup_const(src, GFP_KERNEL);
	3862	+ if (!dst)
	3863	+ return -ENOMEM;
	3864	+
	3865	+ return 0;
	3866	+}
	3867	+
	3868	+static int clk_core_populate_parent_map(struct clk_core *core,
	3869	+ const struct clk_init_data *init)
	3870	+{
	3871	+ u8 num_parents = init->num_parents;
	3872	+ const char * const *parent_names = init->parent_names;
	3873	+ const struct clk_hw **parent_hws = init->parent_hws;
	3874	+ const struct clk_parent_data *parent_data = init->parent_data;
	3875	+ int i, ret = 0;
	3876	+ struct clk_parent_map parents, parent;
	3877	+
	3878	+ if (!num_parents)
	3879	+ return 0;
	3880	+
	3881	+ /*
	3882	+ * Avoid unnecessary string look-ups of clk_core's possible parents by
	3883	+ * having a cache of names/clk_hw pointers to clk_core pointers.
	3884	+ */
	3885	+ parents = kcalloc(num_parents, sizeof(*parents), GFP_KERNEL);
	3886	+ core->parents = parents;
	3887	+ if (!parents)
	3888	+ return -ENOMEM;
	3889	+
	3890	+ /* Copy everything over because it might be __initdata */
	3891	+ for (i = 0, parent = parents; i < num_parents; i++, parent++) {
	3892	+ parent->index = -1;
	3893	+ if (parent_names) {
	3894	+ /* throw a WARN if any entries are NULL */
	3895	+ WARN(!parent_names[i],
	3896	+ "%s: invalid NULL in %s's .parent_names\n",
	3897	+ __func__, core->name);
	3898	+ ret = clk_cpy_name(&parent->name, parent_names[i],
	3899	+ true);
	3900	+ } else if (parent_data) {
	3901	+ parent->hw = parent_data[i].hw;
	3902	+ parent->index = parent_data[i].index;
	3903	+ ret = clk_cpy_name(&parent->fw_name,
	3904	+ parent_data[i].fw_name, false);
	3905	+ if (!ret)
	3906	+ ret = clk_cpy_name(&parent->name,
	3907	+ parent_data[i].name,
	3908	+ false);
	3909	+ } else if (parent_hws) {
	3910	+ parent->hw = parent_hws[i];
	3911	+ } else {
	3912	+ ret = -EINVAL;
	3913	+ WARN(1, "Must specify parents if num_parents > 0\n");
	3914	+ }
	3915	+
	3916	+ if (ret) {
	3917	+ do {
	3918	+ kfree_const(parents[i].name);
	3919	+ kfree_const(parents[i].fw_name);
	3920	+ } while (--i >= 0);
	3921	+ kfree(parents);
	3922	+
	3923	+ return ret;
	3924	+ }
	3925	+ }
	3926	+
	3927	+ return 0;
	3928	+}
	3929	+
	3930	+static void clk_core_free_parent_map(struct clk_core *core)
	3931	+{
	3932	+ int i = core->num_parents;
	3933	+
	3934	+ if (!core->num_parents)
	3935	+ return;
	3936	+
	3937	+ while (--i >= 0) {
	3938	+ kfree_const(core->parents[i].name);
	3939	+ kfree_const(core->parents[i].fw_name);
	3940	+ }
	3941	+
	3942	+ kfree(core->parents);
	3943	+}
	3944	+
	3945	+static struct clk *
	3946	+__clk_register(struct device dev, struct device_node np, struct clk_hw *hw)
	3947	+{
	3948	+ int ret;
	3949	+ struct clk_core *core;
	3950	+ const struct clk_init_data *init = hw->init;
	3951	+
	3952	+ /*
	3953	+ * The init data is not supposed to be used outside of registration path.
	3954	+ * Set it to NULL so that provider drivers can't use it either and so that
	3955	+ * we catch use of hw->init early on in the core.
	3956	+ */
	3957	+ hw->init = NULL;
4014	3958
4015	3959	core = kzalloc(sizeof(*core), GFP_KERNEL);
4016	3960	if (!core) {
..	..	@@ -4018,90 +3962,108 @@
4018	3962	goto fail_out;
4019	3963	}
4020	3964
4021		- core->name = kstrdup_const(hw->init->name, GFP_KERNEL);
	3965	+ core->name = kstrdup_const(init->name, GFP_KERNEL);
4022	3966	if (!core->name) {
4023	3967	ret = -ENOMEM;
4024	3968	goto fail_name;
4025	3969	}
4026	3970
4027		- if (WARN_ON(!hw->init->ops)) {
	3971	+ if (WARN_ON(!init->ops)) {
4028	3972	ret = -EINVAL;
4029	3973	goto fail_ops;
4030	3974	}
4031		- core->ops = hw->init->ops;
	3975	+ core->ops = init->ops;
4032	3976
4033	3977	if (dev && pm_runtime_enabled(dev))
4034	3978	core->rpm_enabled = true;
4035	3979	core->dev = dev;
	3980	+ core->of_node = np;
4036	3981	if (dev && dev->driver)
4037	3982	core->owner = dev->driver->owner;
4038	3983	core->hw = hw;
4039		- core->flags = hw->init->flags;
4040		- core->num_parents = hw->init->num_parents;
	3984	+ core->flags = init->flags;
	3985	+ core->num_parents = init->num_parents;
4041	3986	core->min_rate = 0;
4042	3987	core->max_rate = ULONG_MAX;
4043		- core->vdd_class = hw->init->vdd_class;
4044		- core->rate_max = hw->init->rate_max;
4045		- core->num_rate_max = hw->init->num_rate_max;
4046		- hw->core = core;
4047	3988
4048		- /* allocate local copy in case parent_names is __initdata */
4049		- core->parent_names = kcalloc(core->num_parents, sizeof(char *),
4050		- GFP_KERNEL);
4051		-
4052		- if (!core->parent_names) {
4053		- ret = -ENOMEM;
4054		- goto fail_parent_names;
4055		- }
4056		-
4057		-
4058		- /* copy each string name in case parent_names is __initdata */
4059		- for (i = 0; i < core->num_parents; i++) {
4060		- core->parent_names[i] = kstrdup_const(hw->init->parent_names[i],
4061		- GFP_KERNEL);
4062		- if (!core->parent_names[i]) {
4063		- ret = -ENOMEM;
4064		- goto fail_parent_names_copy;
4065		- }
4066		- }
4067		-
4068		- /* avoid unnecessary string look-ups of clk_core's possible parents. */
4069		- core->parents = kcalloc(core->num_parents, sizeof(*core->parents),
4070		- GFP_KERNEL);
4071		- if (!core->parents) {
4072		- ret = -ENOMEM;
	3989	+ ret = clk_core_populate_parent_map(core, init);
	3990	+ if (ret)
4073	3991	goto fail_parents;
4074		- };
4075	3992
4076	3993	INIT_HLIST_HEAD(&core->clks);
4077		- INIT_LIST_HEAD(&core->rate_change_node);
4078	3994
4079		- hw->clk = clk_hw_create_clk(hw, NULL, NULL);
	3995	+ /*
	3996	+ * Don't call clk_hw_create_clk() here because that would pin the
	3997	+ * provider module to itself and prevent it from ever being removed.
	3998	+ */
	3999	+ hw->clk = alloc_clk(core, NULL, NULL);
4080	4000	if (IS_ERR(hw->clk)) {
4081	4001	ret = PTR_ERR(hw->clk);
4082		- goto fail_parents;
	4002	+ goto fail_create_clk;
4083	4003	}
	4004	+
	4005	+ clk_core_link_consumer(core, hw->clk);
4084	4006
4085	4007	ret = __clk_core_init(core);
4086	4008	if (!ret)
4087	4009	return hw->clk;
4088	4010
4089		- __clk_free_clk(hw->clk);
	4011	+ clk_prepare_lock();
	4012	+ clk_core_unlink_consumer(hw->clk);
	4013	+ clk_prepare_unlock();
	4014	+
	4015	+ free_clk(hw->clk);
4090	4016	hw->clk = NULL;
4091	4017
	4018	+fail_create_clk:
	4019	+ clk_core_free_parent_map(core);
4092	4020	fail_parents:
4093		- kfree(core->parents);
4094		-fail_parent_names_copy:
4095		- while (--i >= 0)
4096		- kfree_const(core->parent_names[i]);
4097		- kfree(core->parent_names);
4098		-fail_parent_names:
4099	4021	fail_ops:
4100	4022	kfree_const(core->name);
4101	4023	fail_name:
4102	4024	kfree(core);
4103	4025	fail_out:
4104	4026	return ERR_PTR(ret);
	4027	+}
	4028	+
	4029	+/**
	4030	+ * dev_or_parent_of_node() - Get device node of @dev or @dev's parent
	4031	+ * @dev: Device to get device node of
	4032	+ *
	4033	+ * Return: device node pointer of @dev, or the device node pointer of
	4034	+ * @dev->parent if dev doesn't have a device node, or NULL if neither
	4035	+ * @dev or @dev->parent have a device node.
	4036	+ */
	4037	+static struct device_node dev_or_parent_of_node(struct device dev)
	4038	+{
	4039	+ struct device_node *np;
	4040	+
	4041	+ if (!dev)
	4042	+ return NULL;
	4043	+
	4044	+ np = dev_of_node(dev);
	4045	+ if (!np)
	4046	+ np = dev_of_node(dev->parent);
	4047	+
	4048	+ return np;
	4049	+}
	4050	+
	4051	+/**
	4052	+ * clk_register - allocate a new clock, register it and return an opaque cookie
	4053	+ * @dev: device that is registering this clock
	4054	+ * @hw: link to hardware-specific clock data
	4055	+ *
	4056	+ * clk_register is the deprecated interface for populating the clock tree with
	4057	+ * new clock nodes. Use clk_hw_register() instead.
	4058	+ *
	4059	+ * Returns: a pointer to the newly allocated struct clk which
	4060	+ * cannot be dereferenced by driver code but may be used in conjunction with the
	4061	+ * rest of the clock API. In the event of an error clk_register will return an
	4062	+ * error code; drivers must test for an error code after calling clk_register.
	4063	+ */
	4064	+struct clk clk_register(struct device dev, struct clk_hw *hw)
	4065	+{
	4066	+ return __clk_register(dev, dev_or_parent_of_node(dev), hw);
4105	4067	}
4106	4068	EXPORT_SYMBOL_GPL(clk_register);
4107	4069
..	..	@@ -4117,23 +4079,36 @@
4117	4079	*/
4118	4080	int clk_hw_register(struct device dev, struct clk_hw hw)
4119	4081	{
4120		- return PTR_ERR_OR_ZERO(clk_register(dev, hw));
	4082	+ return PTR_ERR_OR_ZERO(__clk_register(dev, dev_or_parent_of_node(dev),
	4083	+ hw));
4121	4084	}
4122	4085	EXPORT_SYMBOL_GPL(clk_hw_register);
	4086	+
	4087	+/*
	4088	+ * of_clk_hw_register - register a clk_hw and return an error code
	4089	+ * @node: device_node of device that is registering this clock
	4090	+ * @hw: link to hardware-specific clock data
	4091	+ *
	4092	+ * of_clk_hw_register() is the primary interface for populating the clock tree
	4093	+ * with new clock nodes when a struct device is not available, but a struct
	4094	+ * device_node is. It returns an integer equal to zero indicating success or
	4095	+ * less than zero indicating failure. Drivers must test for an error code after
	4096	+ * calling of_clk_hw_register().
	4097	+ */
	4098	+int of_clk_hw_register(struct device_node node, struct clk_hw hw)
	4099	+{
	4100	+ return PTR_ERR_OR_ZERO(__clk_register(NULL, node, hw));
	4101	+}
	4102	+EXPORT_SYMBOL_GPL(of_clk_hw_register);
4123	4103
4124	4104	/* Free memory allocated for a clock. */
4125	4105	static void __clk_release(struct kref *ref)
4126	4106	{
4127	4107	struct clk_core *core = container_of(ref, struct clk_core, ref);
4128		- int i = core->num_parents;
4129	4108
4130	4109	lockdep_assert_held(&prepare_lock);
4131	4110
4132		- kfree(core->parents);
4133		- while (--i >= 0)
4134		- kfree_const(core->parent_names[i]);
4135		-
4136		- kfree(core->parent_names);
	4111	+ clk_core_free_parent_map(core);
4137	4112	kfree_const(core->name);
4138	4113	kfree(core);
4139	4114	}
..	..	@@ -4180,8 +4155,8 @@
4180	4155	struct clk_core *child;
4181	4156
4182	4157	for (i = 0; i < root->num_parents; i++)
4183		- if (root->parents[i] == target)
4184		- root->parents[i] = NULL;
	4158	+ if (root->parents[i].core == target)
	4159	+ root->parents[i].core = NULL;
4185	4160
4186	4161	hlist_for_each_entry(child, &root->children, child_node)
4187	4162	clk_core_evict_parent_cache_subtree(child, target);
..	..	@@ -4208,6 +4183,7 @@
4208	4183	void clk_unregister(struct clk *clk)
4209	4184	{
4210	4185	unsigned long flags;
	4186	+ const struct clk_ops *ops;
4211	4187
4212	4188	if (!clk \|\| WARN_ON_ONCE(IS_ERR(clk)))
4213	4189	return;
..	..	@@ -4216,7 +4192,8 @@
4216	4192
4217	4193	clk_prepare_lock();
4218	4194
4219		- if (clk->core->ops == &clk_nodrv_ops) {
	4195	+ ops = clk->core->ops;
	4196	+ if (ops == &clk_nodrv_ops) {
4220	4197	pr_err("%s: unregistered clock: %s\n", __func__,
4221	4198	clk->core->name);
4222	4199	goto unlock;
..	..	@@ -4228,6 +4205,9 @@
4228	4205	flags = clk_enable_lock();
4229	4206	clk->core->ops = &clk_nodrv_ops;
4230	4207	clk_enable_unlock(flags);
	4208	+
	4209	+ if (ops->terminate)
	4210	+ ops->terminate(clk->core->hw);
4231	4211
4232	4212	if (!hlist_empty(&clk->core->children)) {
4233	4213	struct clk_core *child;
..	..	@@ -4252,6 +4232,7 @@
4252	4232	__func__, clk->core->name);
4253	4233
4254	4234	kref_put(&clk->core->ref, __clk_release);
	4235	+ free_clk(clk);
4255	4236	unlock:
4256	4237	clk_prepare_unlock();
4257	4238	}
..	..	@@ -4267,174 +4248,14 @@
4267	4248	}
4268	4249	EXPORT_SYMBOL_GPL(clk_hw_unregister);
4269	4250
4270		-static void devm_clk_release(struct device dev, void res)
	4251	+static void devm_clk_unregister_cb(struct device dev, void res)
4271	4252	{
4272	4253	clk_unregister((struct clk *)res);
4273	4254	}
4274	4255
4275		-static void devm_clk_hw_release(struct device dev, void res)
	4256	+static void devm_clk_hw_unregister_cb(struct device dev, void res)
4276	4257	{
4277	4258	clk_hw_unregister((struct clk_hw *)res);
4278		-}
4279		-
4280		-#define MAX_LEN_OPP_HANDLE 50
4281		-#define LEN_OPP_HANDLE 16
4282		-
4283		-static int derive_device_list(struct device **device_list,
4284		- struct clk_core *core,
4285		- struct device_node *np,
4286		- char *clk_handle_name, int count)
4287		-{
4288		- int j;
4289		- struct platform_device *pdev;
4290		- struct device_node *dev_node;
4291		-
4292		- for (j = 0; j < count; j++) {
4293		- device_list[j] = NULL;
4294		- dev_node = of_parse_phandle(np, clk_handle_name, j);
4295		- if (!dev_node) {
4296		- pr_err("Unable to get device_node pointer for %s opp-handle (%s)\n",
4297		- core->name, clk_handle_name);
4298		- return -ENODEV;
4299		- }
4300		-
4301		- pdev = of_find_device_by_node(dev_node);
4302		- if (!pdev) {
4303		- pr_err("Unable to find platform_device node for %s opp-handle\n",
4304		- core->name);
4305		- return -ENODEV;
4306		- }
4307		- device_list[j] = &pdev->dev;
4308		- }
4309		- return 0;
4310		-}
4311		-
4312		-static int clk_get_voltage(struct clk_core *core, unsigned long rate, int n)
4313		-{
4314		- struct clk_vdd_class *vdd;
4315		- int level, corner;
4316		-
4317		- /* Use the first regulator in the vdd class for the OPP table. */
4318		- vdd = core->vdd_class;
4319		- if (vdd->num_regulators > 1) {
4320		- corner = vdd->vdd_uv[vdd->num_regulators * n];
4321		- } else {
4322		- level = clk_find_vdd_level(core, rate);
4323		- if (level < 0) {
4324		- pr_err("Could not find vdd level\n");
4325		- return -EINVAL;
4326		- }
4327		- corner = vdd->vdd_uv[level];
4328		- }
4329		-
4330		- if (!corner) {
4331		- pr_err("%s: Unable to find vdd level for rate %lu\n",
4332		- core->name, rate);
4333		- return -EINVAL;
4334		- }
4335		-
4336		- return corner;
4337		-}
4338		-
4339		-static int clk_add_and_print_opp(struct clk_hw *hw,
4340		- struct device **device_list, int count,
4341		- unsigned long rate, int uv, int n)
4342		-{
4343		- struct clk_core *core = hw->core;
4344		- int j, ret = 0;
4345		-
4346		- for (j = 0; j < count; j++) {
4347		- ret = dev_pm_opp_add(device_list[j], rate, uv);
4348		- if (ret) {
4349		- pr_err("%s: couldn't add OPP for %lu - err: %d\n",
4350		- core->name, rate, ret);
4351		- return ret;
4352		- }
4353		-
4354		- if (n == 0 \|\| n == core->num_rate_max - 1 \|\|
4355		- rate == clk_hw_round_rate(hw, INT_MAX))
4356		- pr_info("%s: set OPP pair(%lu Hz: %u uV) on %s\n",
4357		- core->name, rate, uv,
4358		- dev_name(device_list[j]));
4359		- }
4360		- return ret;
4361		-}
4362		-
4363		-static void clk_populate_clock_opp_table(struct device_node *np,
4364		- struct clk_hw *hw)
4365		-{
4366		- struct device **device_list;
4367		- struct clk_core *core = hw->core;
4368		- char clk_handle_name[MAX_LEN_OPP_HANDLE];
4369		- int n, len, count, uv, ret;
4370		- unsigned long rate = 0, rrate = 0;
4371		-
4372		- if (!core \|\| !core->num_rate_max)
4373		- return;
4374		-
4375		- if (strlen(core->name) + LEN_OPP_HANDLE < MAX_LEN_OPP_HANDLE) {
4376		- ret = snprintf(clk_handle_name, ARRAY_SIZE(clk_handle_name),
4377		- "qcom,%s-opp-handle", core->name);
4378		- if (ret < strlen(core->name) + LEN_OPP_HANDLE) {
4379		- pr_err("%s: Failed to hold clk_handle_name\n",
4380		- core->name);
4381		- return;
4382		- }
4383		- } else {
4384		- pr_err("clk name (%s) too large to fit in clk_handle_name\n",
4385		- core->name);
4386		- return;
4387		- }
4388		-
4389		- if (of_find_property(np, clk_handle_name, &len)) {
4390		- count = len/sizeof(u32);
4391		-
4392		- device_list = kmalloc_array(count, sizeof(struct device *),
4393		- GFP_KERNEL);
4394		- if (!device_list)
4395		- return;
4396		-
4397		- ret = derive_device_list(device_list, core, np,
4398		- clk_handle_name, count);
4399		- if (ret < 0) {
4400		- pr_err("Failed to fill device_list for %s\n",
4401		- clk_handle_name);
4402		- goto err_derive_device_list;
4403		- }
4404		- } else {
4405		- pr_debug("Unable to find %s\n", clk_handle_name);
4406		- return;
4407		- }
4408		-
4409		- for (n = 0; ; n++) {
4410		- rrate = clk_hw_round_rate(hw, rate + 1);
4411		- if (!rrate) {
4412		- pr_err("clk_round_rate failed for %s\n",
4413		- core->name);
4414		- goto err_derive_device_list;
4415		- }
4416		-
4417		- /*
4418		- * If clk_hw_round_rate gives the same value on consecutive
4419		- * iterations, exit the loop since we're at the maximum clock
4420		- * frequency.
4421		- */
4422		- if (rate == rrate)
4423		- break;
4424		- rate = rrate;
4425		-
4426		- uv = clk_get_voltage(core, rate, n);
4427		- if (uv < 0)
4428		- goto err_derive_device_list;
4429		-
4430		- ret = clk_add_and_print_opp(hw, device_list, count,
4431		- rate, uv, n);
4432		- if (ret)
4433		- goto err_derive_device_list;
4434		- }
4435		-
4436		-err_derive_device_list:
4437		- kfree(device_list);
4438	4259	}
4439	4260
4440	4261	/**
..	..	@@ -4442,16 +4263,17 @@
4442	4263	* @dev: device that is registering this clock
4443	4264	* @hw: link to hardware-specific clock data
4444	4265	*
4445		- * Managed clk_register(). Clocks returned from this function are
4446		- * automatically clk_unregister()ed on driver detach. See clk_register() for
4447		- * more information.
	4266	+ * Managed clk_register(). This function is deprecated, use devm_clk_hw_register() instead.
	4267	+ *
	4268	+ * Clocks returned from this function are automatically clk_unregister()ed on
	4269	+ * driver detach. See clk_register() for more information.
4448	4270	*/
4449	4271	struct clk devm_clk_register(struct device dev, struct clk_hw *hw)
4450	4272	{
4451	4273	struct clk *clk;
4452	4274	struct clk **clkp;
4453	4275
4454		- clkp = devres_alloc(devm_clk_release, sizeof(*clkp), GFP_KERNEL);
	4276	+ clkp = devres_alloc(devm_clk_unregister_cb, sizeof(*clkp), GFP_KERNEL);
4455	4277	if (!clkp)
4456	4278	return ERR_PTR(-ENOMEM);
4457	4279
..	..	@@ -4463,7 +4285,6 @@
4463	4285	devres_free(clkp);
4464	4286	}
4465	4287
4466		- clk_populate_clock_opp_table(dev->of_node, hw);
4467	4288	return clk;
4468	4289	}
4469	4290	EXPORT_SYMBOL_GPL(devm_clk_register);
..	..	@@ -4482,7 +4303,7 @@
4482	4303	struct clk_hw **hwp;
4483	4304	int ret;
4484	4305
4485		- hwp = devres_alloc(devm_clk_hw_release, sizeof(*hwp), GFP_KERNEL);
	4306	+ hwp = devres_alloc(devm_clk_hw_unregister_cb, sizeof(*hwp), GFP_KERNEL);
4486	4307	if (!hwp)
4487	4308	return -ENOMEM;
4488	4309
..	..	@@ -4494,7 +4315,6 @@
4494	4315	devres_free(hwp);
4495	4316	}
4496	4317
4497		- clk_populate_clock_opp_table(dev->of_node, hw);
4498	4318	return ret;
4499	4319	}
4500	4320	EXPORT_SYMBOL_GPL(devm_clk_hw_register);
..	..	@@ -4518,6 +4338,7 @@
4518	4338
4519	4339	/**
4520	4340	* devm_clk_unregister - resource managed clk_unregister()
	4341	+ * @dev: device that is unregistering the clock data
4521	4342	* @clk: clock to unregister
4522	4343	*
4523	4344	* Deallocate a clock allocated with devm_clk_register(). Normally
..	..	@@ -4526,7 +4347,7 @@
4526	4347	*/
4527	4348	void devm_clk_unregister(struct device dev, struct clk clk)
4528	4349	{
4529		- WARN_ON(devres_release(dev, devm_clk_release, devm_clk_match, clk));
	4350	+ WARN_ON(devres_release(dev, devm_clk_unregister_cb, devm_clk_match, clk));
4530	4351	}
4531	4352	EXPORT_SYMBOL_GPL(devm_clk_unregister);
4532	4353
..	..	@@ -4541,28 +4362,58 @@
4541	4362	*/
4542	4363	void devm_clk_hw_unregister(struct device dev, struct clk_hw hw)
4543	4364	{
4544		- WARN_ON(devres_release(dev, devm_clk_hw_release, devm_clk_hw_match,
	4365	+ WARN_ON(devres_release(dev, devm_clk_hw_unregister_cb, devm_clk_hw_match,
4545	4366	hw));
4546	4367	}
4547	4368	EXPORT_SYMBOL_GPL(devm_clk_hw_unregister);
4548	4369
	4370	+static void devm_clk_release(struct device dev, void res)
	4371	+{
	4372	+ clk_put((struct clk *)res);
	4373	+}
	4374	+
	4375	+/**
	4376	+ * devm_clk_hw_get_clk - resource managed clk_hw_get_clk()
	4377	+ * @dev: device that is registering this clock
	4378	+ * @hw: clk_hw associated with the clk being consumed
	4379	+ * @con_id: connection ID string on device
	4380	+ *
	4381	+ * Managed clk_hw_get_clk(). Clocks got with this function are
	4382	+ * automatically clk_put() on driver detach. See clk_put()
	4383	+ * for more information.
	4384	+ */
	4385	+struct clk devm_clk_hw_get_clk(struct device dev, struct clk_hw *hw,
	4386	+ const char *con_id)
	4387	+{
	4388	+ struct clk *clk;
	4389	+ struct clk **clkp;
	4390	+
	4391	+ /* This should not happen because it would mean we have drivers
	4392	+ * passing around clk_hw pointers instead of having the caller use
	4393	+ * proper clk_get() style APIs
	4394	+ */
	4395	+ WARN_ON_ONCE(dev != hw->core->dev);
	4396	+
	4397	+ clkp = devres_alloc(devm_clk_release, sizeof(*clkp), GFP_KERNEL);
	4398	+ if (!clkp)
	4399	+ return ERR_PTR(-ENOMEM);
	4400	+
	4401	+ clk = clk_hw_get_clk(hw, con_id);
	4402	+ if (!IS_ERR(clk)) {
	4403	+ *clkp = clk;
	4404	+ devres_add(dev, clkp);
	4405	+ } else {
	4406	+ devres_free(clkp);
	4407	+ }
	4408	+
	4409	+ return clk;
	4410	+}
	4411	+EXPORT_SYMBOL_GPL(devm_clk_hw_get_clk);
	4412	+
4549	4413	/*
4550	4414	* clkdev helpers
4551	4415	*/
4552		-int __clk_get(struct clk *clk)
4553		-{
4554		- struct clk_core *core = !clk ? NULL : clk->core;
4555	4416
4556		- if (core) {
4557		- if (!try_module_get(core->owner))
4558		- return 0;
4559		-
4560		- kref_get(&core->ref);
4561		- }
4562		- return 1;
4563		-}
4564		-
4565		-/* keep in sync with __clk_free_clk */
4566	4417	void __clk_put(struct clk *clk)
4567	4418	{
4568	4419	struct module *owner;
..	..	@@ -4596,8 +4447,7 @@
4596	4447
4597	4448	module_put(owner);
4598	4449
4599		- kfree_const(clk->con_id);
4600		- kfree(clk);
	4450	+ free_clk(clk);
4601	4451	}
4602	4452
4603	4453	/* clk rate change notifiers */
..	..	@@ -4702,13 +4552,58 @@
4702	4552	}
4703	4553	EXPORT_SYMBOL_GPL(clk_notifier_unregister);
4704	4554
	4555	+struct clk_notifier_devres {
	4556	+ struct clk *clk;
	4557	+ struct notifier_block *nb;
	4558	+};
	4559	+
	4560	+static void devm_clk_notifier_release(struct device dev, void res)
	4561	+{
	4562	+ struct clk_notifier_devres *devres = res;
	4563	+
	4564	+ clk_notifier_unregister(devres->clk, devres->nb);
	4565	+}
	4566	+
	4567	+int devm_clk_notifier_register(struct device dev, struct clk clk,
	4568	+ struct notifier_block *nb)
	4569	+{
	4570	+ struct clk_notifier_devres *devres;
	4571	+ int ret;
	4572	+
	4573	+ devres = devres_alloc(devm_clk_notifier_release,
	4574	+ sizeof(*devres), GFP_KERNEL);
	4575	+
	4576	+ if (!devres)
	4577	+ return -ENOMEM;
	4578	+
	4579	+ ret = clk_notifier_register(clk, nb);
	4580	+ if (!ret) {
	4581	+ devres->clk = clk;
	4582	+ devres->nb = nb;
	4583	+ } else {
	4584	+ devres_free(devres);
	4585	+ }
	4586	+
	4587	+ return ret;
	4588	+}
	4589	+EXPORT_SYMBOL_GPL(devm_clk_notifier_register);
	4590	+
4705	4591	#ifdef CONFIG_OF
	4592	+static void clk_core_reparent_orphans(void)
	4593	+{
	4594	+ clk_prepare_lock();
	4595	+ clk_core_reparent_orphans_nolock();
	4596	+ clk_prepare_unlock();
	4597	+}
	4598	+
4706	4599	/**
4707	4600	* struct of_clk_provider - Clock provider registration structure
4708	4601	* @link: Entry in global list of clock providers
4709	4602	* @node: Pointer to device tree node of clock provider
4710	4603	* @get: Get clock callback. Returns NULL or a struct clk for the
4711	4604	* given clock specifier
	4605	+ * @get_hw: Get clk_hw callback. Returns NULL, ERR_PTR or a
	4606	+ * struct clk_hw for the given clock specifier
4712	4607	* @data: context pointer to be passed into @get callback
4713	4608	*/
4714	4609	struct of_clk_provider {
..	..	@@ -4720,8 +4615,9 @@
4720	4615	void *data;
4721	4616	};
4722	4617
	4618	+extern struct of_device_id __clk_of_table;
4723	4619	static const struct of_device_id __clk_of_table_sentinel
4724		- __used __section(__clk_of_table_end);
	4620	+ __used __section("__clk_of_table_end");
4725	4621
4726	4622	static LIST_HEAD(of_clk_providers);
4727	4623	static DEFINE_MUTEX(of_clk_mutex);
..	..	@@ -4773,6 +4669,8 @@
4773	4669	* @np: Device node pointer associated with clock provider
4774	4670	* @clk_src_get: callback for decoding clock
4775	4671	* @data: context pointer for @clk_src_get callback.
	4672	+ *
	4673	+ * This function is deprecated. Use of_clk_add_hw_provider() instead.
4776	4674	*/
4777	4675	int of_clk_add_provider(struct device_node *np,
4778	4676	struct clk (clk_src_get)(struct of_phandle_args *clkspec,
..	..	@@ -4781,6 +4679,9 @@
4781	4679	{
4782	4680	struct of_clk_provider *cp;
4783	4681	int ret;
	4682	+
	4683	+ if (!np)
	4684	+ return 0;
4784	4685
4785	4686	cp = kzalloc(sizeof(*cp), GFP_KERNEL);
4786	4687	if (!cp)
..	..	@@ -4795,9 +4696,13 @@
4795	4696	mutex_unlock(&of_clk_mutex);
4796	4697	pr_debug("Added clock from %pOF\n", np);
4797	4698
	4699	+ clk_core_reparent_orphans();
	4700	+
4798	4701	ret = of_clk_set_defaults(np, true);
4799	4702	if (ret < 0)
4800	4703	of_clk_del_provider(np);
	4704	+
	4705	+ fwnode_dev_initialized(&np->fwnode, true);
4801	4706
4802	4707	return ret;
4803	4708	}
..	..	@@ -4817,6 +4722,9 @@
4817	4722	struct of_clk_provider *cp;
4818	4723	int ret;
4819	4724
	4725	+ if (!np)
	4726	+ return 0;
	4727	+
4820	4728	cp = kzalloc(sizeof(*cp), GFP_KERNEL);
4821	4729	if (!cp)
4822	4730	return -ENOMEM;
..	..	@@ -4829,6 +4737,8 @@
4829	4737	list_add(&cp->link, &of_clk_providers);
4830	4738	mutex_unlock(&of_clk_mutex);
4831	4739	pr_debug("Added clk_hw provider from %pOF\n", np);
	4740	+
	4741	+ clk_core_reparent_orphans();
4832	4742
4833	4743	ret = of_clk_set_defaults(np, true);
4834	4744	if (ret < 0)
..	..	@@ -4843,6 +4753,39 @@
4843	4753	of_clk_del_provider((struct device_node *)res);
4844	4754	}
4845	4755
	4756	+/*
	4757	+ * We allow a child device to use its parent device as the clock provider node
	4758	+ * for cases like MFD sub-devices where the child device driver wants to use
	4759	+ * devm_*() APIs but not list the device in DT as a sub-node.
	4760	+ */
	4761	+static struct device_node get_clk_provider_node(struct device dev)
	4762	+{
	4763	+ struct device_node np, parent_np;
	4764	+
	4765	+ np = dev->of_node;
	4766	+ parent_np = dev->parent ? dev->parent->of_node : NULL;
	4767	+
	4768	+ if (!of_find_property(np, "#clock-cells", NULL))
	4769	+ if (of_find_property(parent_np, "#clock-cells", NULL))
	4770	+ np = parent_np;
	4771	+
	4772	+ return np;
	4773	+}
	4774	+
	4775	+/**
	4776	+ * devm_of_clk_add_hw_provider() - Managed clk provider node registration
	4777	+ * @dev: Device acting as the clock provider (used for DT node and lifetime)
	4778	+ * @get: callback for decoding clk_hw
	4779	+ * @data: context pointer for @get callback
	4780	+ *
	4781	+ * Registers clock provider for given device's node. If the device has no DT
	4782	+ * node or if the device node lacks of clock provider information (#clock-cells)
	4783	+ * then the parent device's node is scanned for this information. If parent node
	4784	+ * has the #clock-cells then it is used in registration. Provider is
	4785	+ * automatically released at device exit.
	4786	+ *
	4787	+ * Return: 0 on success or an errno on failure.
	4788	+ */
4846	4789	int devm_of_clk_add_hw_provider(struct device *dev,
4847	4790	struct clk_hw (get)(struct of_phandle_args *clkspec,
4848	4791	void *data),
..	..	@@ -4856,7 +4799,7 @@
4856	4799	if (!ptr)
4857	4800	return -ENOMEM;
4858	4801
4859		- np = dev->of_node;
	4802	+ np = get_clk_provider_node(dev);
4860	4803	ret = of_clk_add_hw_provider(np, get, data);
4861	4804	if (!ret) {
4862	4805	*ptr = np;
..	..	@@ -4877,10 +4820,14 @@
4877	4820	{
4878	4821	struct of_clk_provider *cp;
4879	4822
	4823	+ if (!np)
	4824	+ return;
	4825	+
4880	4826	mutex_lock(&of_clk_mutex);
4881	4827	list_for_each_entry(cp, &of_clk_providers, link) {
4882	4828	if (cp->node == np) {
4883	4829	list_del(&cp->link);
	4830	+ fwnode_dev_initialized(&np->fwnode, false);
4884	4831	of_node_put(cp->node);
4885	4832	kfree(cp);
4886	4833	break;
..	..	@@ -4900,16 +4847,95 @@
4900	4847	return *np == data;
4901	4848	}
4902	4849
	4850	+/**
	4851	+ * devm_of_clk_del_provider() - Remove clock provider registered using devm
	4852	+ * @dev: Device to whose lifetime the clock provider was bound
	4853	+ */
4903	4854	void devm_of_clk_del_provider(struct device *dev)
4904	4855	{
4905	4856	int ret;
	4857	+ struct device_node *np = get_clk_provider_node(dev);
4906	4858
4907	4859	ret = devres_release(dev, devm_of_clk_release_provider,
4908		- devm_clk_provider_match, dev->of_node);
	4860	+ devm_clk_provider_match, np);
4909	4861
4910	4862	WARN_ON(ret);
4911	4863	}
4912	4864	EXPORT_SYMBOL(devm_of_clk_del_provider);
	4865	+
	4866	+/**
	4867	+ * of_parse_clkspec() - Parse a DT clock specifier for a given device node
	4868	+ * @np: device node to parse clock specifier from
	4869	+ * @index: index of phandle to parse clock out of. If index < 0, @name is used
	4870	+ * @name: clock name to find and parse. If name is NULL, the index is used
	4871	+ * @out_args: Result of parsing the clock specifier
	4872	+ *
	4873	+ * Parses a device node's "clocks" and "clock-names" properties to find the
	4874	+ * phandle and cells for the index or name that is desired. The resulting clock
	4875	+ * specifier is placed into @out_args, or an errno is returned when there's a
	4876	+ * parsing error. The @index argument is ignored if @name is non-NULL.
	4877	+ *
	4878	+ * Example:
	4879	+ *
	4880	+ * phandle1: clock-controller@1 {
	4881	+ * #clock-cells = <2>;
	4882	+ * }
	4883	+ *
	4884	+ * phandle2: clock-controller@2 {
	4885	+ * #clock-cells = <1>;
	4886	+ * }
	4887	+ *
	4888	+ * clock-consumer@3 {
	4889	+ * clocks = <&phandle1 1 2 &phandle2 3>;
	4890	+ * clock-names = "name1", "name2";
	4891	+ * }
	4892	+ *
	4893	+ * To get a device_node for `clock-controller@2' node you may call this
	4894	+ * function a few different ways:
	4895	+ *
	4896	+ * of_parse_clkspec(clock-consumer@3, -1, "name2", &args);
	4897	+ * of_parse_clkspec(clock-consumer@3, 1, NULL, &args);
	4898	+ * of_parse_clkspec(clock-consumer@3, 1, "name2", &args);
	4899	+ *
	4900	+ * Return: 0 upon successfully parsing the clock specifier. Otherwise, -ENOENT
	4901	+ * if @name is NULL or -EINVAL if @name is non-NULL and it can't be found in
	4902	+ * the "clock-names" property of @np.
	4903	+ */
	4904	+static int of_parse_clkspec(const struct device_node *np, int index,
	4905	+ const char name, struct of_phandle_args out_args)
	4906	+{
	4907	+ int ret = -ENOENT;
	4908	+
	4909	+ /* Walk up the tree of devices looking for a clock property that matches */
	4910	+ while (np) {
	4911	+ /*
	4912	+ * For named clocks, first look up the name in the
	4913	+ * "clock-names" property. If it cannot be found, then index
	4914	+ * will be an error code and of_parse_phandle_with_args() will
	4915	+ * return -EINVAL.
	4916	+ */
	4917	+ if (name)
	4918	+ index = of_property_match_string(np, "clock-names", name);
	4919	+ ret = of_parse_phandle_with_args(np, "clocks", "#clock-cells",
	4920	+ index, out_args);
	4921	+ if (!ret)
	4922	+ break;
	4923	+ if (name && index >= 0)
	4924	+ break;
	4925	+
	4926	+ /*
	4927	+ * No matching clock found on this node. If the parent node
	4928	+ * has a "clock-ranges" property, then we can try one of its
	4929	+ * clocks.
	4930	+ */
	4931	+ np = np->parent;
	4932	+ if (np && !of_get_property(np, "clock-ranges", NULL))
	4933	+ break;
	4934	+ index = 0;
	4935	+ }
	4936	+
	4937	+ return ret;
	4938	+}
4913	4939
4914	4940	static struct clk_hw *
4915	4941	__of_clk_get_hw_from_provider(struct of_clk_provider *provider,
..	..	@@ -4926,38 +4952,26 @@
4926	4952	return __clk_get_hw(clk);
4927	4953	}
4928	4954
4929		-struct clk __of_clk_get_from_provider(struct of_phandle_args clkspec,
4930		- const char dev_id, const char con_id,
4931		- bool with_orphans)
	4955	+static struct clk_hw *
	4956	+of_clk_get_hw_from_clkspec(struct of_phandle_args *clkspec)
4932	4957	{
4933	4958	struct of_clk_provider *provider;
4934		- struct clk *clk = ERR_PTR(-EPROBE_DEFER);
4935		- struct clk_hw *hw;
	4959	+ struct clk_hw *hw = ERR_PTR(-EPROBE_DEFER);
4936	4960
4937	4961	if (!clkspec)
4938	4962	return ERR_PTR(-EINVAL);
4939	4963
4940		- /* Check if we have such a provider in our array */
4941	4964	mutex_lock(&of_clk_mutex);
4942	4965	list_for_each_entry(provider, &of_clk_providers, link) {
4943	4966	if (provider->node == clkspec->np) {
4944	4967	hw = __of_clk_get_hw_from_provider(provider, clkspec);
4945		- clk = __clk_create_clk(hw, dev_id, con_id,
4946		- with_orphans);
4947		- }
4948		-
4949		- if (!IS_ERR(clk)) {
4950		- if (!__clk_get(clk)) {
4951		- __clk_free_clk(clk);
4952		- clk = ERR_PTR(-ENOENT);
4953		- }
4954		-
4955		- break;
	4968	+ if (!IS_ERR(hw))
	4969	+ break;
4956	4970	}
4957	4971	}
4958	4972	mutex_unlock(&of_clk_mutex);
4959	4973
4960		- return clk;
	4974	+ return hw;
4961	4975	}
4962	4976
4963	4977	/**
..	..	@@ -4970,27 +4984,61 @@
4970	4984	*/
4971	4985	struct clk of_clk_get_from_provider(struct of_phandle_args clkspec)
4972	4986	{
4973		- return __of_clk_get_from_provider(clkspec, NULL, __func__, false);
4974		-}
	4987	+ struct clk_hw *hw = of_clk_get_hw_from_clkspec(clkspec);
4975	4988
4976		-/**
4977		- * of_clk_get_from_provider_with_orphans() - Lookup clock from a clock provider
4978		- * @clkspec: pointer to a clock specifier data structure
4979		- *
4980		- * This function looks up a struct clk from the registered list of clock
4981		- * providers, an input is a clock specifier data structure as returned
4982		- * from the of_parse_phandle_with_args() function call.
4983		- *
4984		- * The difference to of_clk_get_from_provider() is that this function will
4985		- * also successfully lookup orphan-clocks, as it in some cases may be
4986		- * necessary to access such orphan-clocks as well.
4987		- */
4988		-struct clk *
4989		-of_clk_get_from_provider_with_orphans(struct of_phandle_args *clkspec)
4990		-{
4991		- return __of_clk_get_from_provider(clkspec, NULL, __func__, true);
	4989	+ return clk_hw_create_clk(NULL, hw, NULL, __func__);
4992	4990	}
4993	4991	EXPORT_SYMBOL_GPL(of_clk_get_from_provider);
	4992	+
	4993	+struct clk_hw of_clk_get_hw(struct device_node np, int index,
	4994	+ const char *con_id)
	4995	+{
	4996	+ int ret;
	4997	+ struct clk_hw *hw;
	4998	+ struct of_phandle_args clkspec;
	4999	+
	5000	+ ret = of_parse_clkspec(np, index, con_id, &clkspec);
	5001	+ if (ret)
	5002	+ return ERR_PTR(ret);
	5003	+
	5004	+ hw = of_clk_get_hw_from_clkspec(&clkspec);
	5005	+ of_node_put(clkspec.np);
	5006	+
	5007	+ return hw;
	5008	+}
	5009	+
	5010	+static struct clk __of_clk_get(struct device_node np,
	5011	+ int index, const char *dev_id,
	5012	+ const char *con_id)
	5013	+{
	5014	+ struct clk_hw *hw = of_clk_get_hw(np, index, con_id);
	5015	+
	5016	+ return clk_hw_create_clk(NULL, hw, dev_id, con_id);
	5017	+}
	5018	+
	5019	+struct clk of_clk_get(struct device_node np, int index)
	5020	+{
	5021	+ return __of_clk_get(np, index, np->full_name, NULL);
	5022	+}
	5023	+EXPORT_SYMBOL(of_clk_get);
	5024	+
	5025	+/**
	5026	+ * of_clk_get_by_name() - Parse and lookup a clock referenced by a device node
	5027	+ * @np: pointer to clock consumer node
	5028	+ * @name: name of consumer's clock input, or NULL for the first clock reference
	5029	+ *
	5030	+ * This function parses the clocks and clock-names properties,
	5031	+ * and uses them to look up the struct clk from the registered list of clock
	5032	+ * providers.
	5033	+ */
	5034	+struct clk of_clk_get_by_name(struct device_node np, const char *name)
	5035	+{
	5036	+ if (!np)
	5037	+ return ERR_PTR(-ENOENT);
	5038	+
	5039	+ return __of_clk_get(np, 0, np->full_name, name);
	5040	+}
	5041	+EXPORT_SYMBOL(of_clk_get_by_name);
4994	5042
4995	5043	/**
4996	5044	* of_clk_get_parent_count() - Count the number of clocks a device node has
..	..	@@ -4998,7 +5046,7 @@
4998	5046	*
4999	5047	* Returns: The number of clocks that are possible parents of this node
5000	5048	*/
5001		-unsigned int of_clk_get_parent_count(struct device_node *np)
	5049	+unsigned int of_clk_get_parent_count(const struct device_node *np)
5002	5050	{
5003	5051	int count;
5004	5052
..	..	@@ -5010,7 +5058,7 @@
5010	5058	}
5011	5059	EXPORT_SYMBOL_GPL(of_clk_get_parent_count);
5012	5060
5013		-const char of_clk_get_parent_name(struct device_node np, int index)
	5061	+const char of_clk_get_parent_name(const struct device_node np, int index)
5014	5062	{
5015	5063	struct of_phandle_args clkspec;
5016	5064	struct property *prop;
..	..	@@ -5150,8 +5198,8 @@
5150	5198	*
5151	5199	* Return: error code or zero on success
5152	5200	*/
5153		-int of_clk_detect_critical(struct device_node *np,
5154		- int index, unsigned long *flags)
	5201	+int of_clk_detect_critical(struct device_node *np, int index,
	5202	+ unsigned long *flags)
5155	5203	{
5156	5204	struct property *prop;
5157	5205	const __be32 *cur;
..	..	@@ -5296,12 +5344,12 @@
5296	5344	return cnt;
5297	5345	}
5298	5346
5299		-static const struct file_operations clk_rate_fops = {
5300		- .open = clk_rate_open,
5301		- .read = seq_read,
5302		- .llseek = seq_lseek,
5303		- .release = single_release,
5304		- .write = clk_rate_write,
	5347	+static const struct proc_ops clk_rate_proc_ops = {
	5348	+ .proc_open = clk_rate_open,
	5349	+ .proc_read = seq_read,
	5350	+ .proc_write = clk_rate_write,
	5351	+ .proc_lseek = seq_lseek,
	5352	+ .proc_release = single_release,
5305	5353	};
5306	5354
5307	5355	static int clk_enable_show(struct seq_file s, void v)
..	..	@@ -5357,12 +5405,12 @@
5357	5405	return cnt;
5358	5406	}
5359	5407
5360		-static const struct file_operations clk_enable_fops = {
5361		- .open = clk_enable_open,
5362		- .read = seq_read,
5363		- .llseek = seq_lseek,
5364		- .release = single_release,
5365		- .write = clk_enable_write,
	5408	+static const struct proc_ops clk_enable_proc_ops = {
	5409	+ .proc_open = clk_enable_open,
	5410	+ .proc_read = seq_read,
	5411	+ .proc_write = clk_enable_write,
	5412	+ .proc_lseek = seq_lseek,
	5413	+ .proc_release = single_release,
5366	5414	};
5367	5415
5368	5416	static int clk_parent_show(struct seq_file s, void v)
..	..	@@ -5416,12 +5464,12 @@
5416	5464	return cnt;
5417	5465	}
5418	5466
5419		-static const struct file_operations clk_parent_fops = {
5420		- .open = clk_parent_open,
5421		- .read = seq_read,
5422		- .llseek = seq_lseek,
5423		- .release = single_release,
5424		- .write = clk_parent_write,
	5467	+static const struct proc_ops clk_parent_proc_ops = {
	5468	+ .proc_open = clk_parent_open,
	5469	+ .proc_read = seq_read,
	5470	+ .proc_write = clk_parent_write,
	5471	+ .proc_lseek = seq_lseek,
	5472	+ .proc_release = single_release,
5425	5473	};
5426	5474
5427	5475	static void clk_proc_summary_show_one(struct seq_file s, struct clk_core c,
..	..	@@ -5434,7 +5482,8 @@
5434	5482	level * 3 + 1, "",
5435	5483	30 - level * 3, c->name,
5436	5484	c->enable_count, c->prepare_count, c->protect_count,
5437		- clk_core_get_rate(c), clk_core_get_accuracy(c),
	5485	+ clk_core_get_rate_recalc(c),
	5486	+ clk_core_get_accuracy_recalc(c),
5438	5487	clk_core_get_phase(c),
5439	5488	clk_core_get_scaled_duty_cycle(c, 100000));
5440	5489	}
..	..	@@ -5487,15 +5536,15 @@
5487	5536	if (!proc_clk_root)
5488	5537	return -EINVAL;
5489	5538
5490		- ent = proc_create("rate", 0644, proc_clk_root, &clk_rate_fops);
	5539	+ ent = proc_create("rate", 0644, proc_clk_root, &clk_rate_proc_ops);
5491	5540	if (!ent)
5492	5541	goto fail;
5493	5542
5494		- ent = proc_create("enable", 0644, proc_clk_root, &clk_enable_fops);
	5543	+ ent = proc_create("enable", 0644, proc_clk_root, &clk_enable_proc_ops);
5495	5544	if (!ent)
5496	5545	goto fail;
5497	5546
5498		- ent = proc_create("parent", 0644, proc_clk_root, &clk_parent_fops);
	5547	+ ent = proc_create("parent", 0644, proc_clk_root, &clk_parent_proc_ops);
5499	5548	if (!ent)
5500	5549	goto fail;
5501	5550