// SPDX-License-Identifier: GPL-2.0

  /*
   * Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
   * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
   *

   * Standard functionality for the common clock API.  See Documentation/driver-api/clk.rst

   */

  #include <linux/clk.h>

  #include <linux/clk-provider.h>

  #include <linux/clk/clk-conf.h>

  #include <linux/module.h>
  #include <linux/mutex.h>
  #include <linux/spinlock.h>
  #include <linux/err.h>
  #include <linux/list.h>
  #include <linux/slab.h>

  #include <linux/of.h>

  #include <linux/device.h>

  #include <linux/init.h>

  #include <linux/pm_runtime.h>

  #include <linux/sched.h>

  #include <linux/clkdev.h>

  #include "clk.h"

  static DEFINE_SPINLOCK(enable_lock);
  static DEFINE_MUTEX(prepare_lock);

  static struct task_struct *prepare_owner;
  static struct task_struct *enable_owner;
  
  static int prepare_refcnt;
  static int enable_refcnt;

  static HLIST_HEAD(clk_root_list);
  static HLIST_HEAD(clk_orphan_list);
  static LIST_HEAD(clk_notifier_list);

  static struct hlist_head *all_lists[] = {
  	&clk_root_list,
  	&clk_orphan_list,
  	NULL,
  };

  /***    private data structures    ***/

  struct clk_parent_map {
  	const struct clk_hw	*hw;
  	struct clk_core		*core;
  	const char		*fw_name;
  	const char		*name;

  	int			index;

  };

  struct clk_core {
  	const char		*name;
  	const struct clk_ops	*ops;
  	struct clk_hw		*hw;
  	struct module		*owner;

  	struct device		*dev;

  	struct device_node	*of_node;

  	struct clk_core		*parent;

  	struct clk_parent_map	*parents;

  	u8			num_parents;
  	u8			new_parent_index;
  	unsigned long		rate;

  	unsigned long		req_rate;

  	unsigned long		new_rate;
  	struct clk_core		*new_parent;
  	struct clk_core		*new_child;
  	unsigned long		flags;

  	bool			orphan;

  	bool			rpm_enabled;

  	unsigned int		enable_count;
  	unsigned int		prepare_count;

  	unsigned int		protect_count;

  	unsigned long		min_rate;
  	unsigned long		max_rate;

  	unsigned long		accuracy;
  	int			phase;

  	struct clk_duty		duty;

  	struct hlist_head	children;
  	struct hlist_node	child_node;

  	struct hlist_head	clks;

  	unsigned int		notifier_count;
  #ifdef CONFIG_DEBUG_FS
  	struct dentry		*dentry;

  	struct hlist_node	debug_node;

  #endif
  	struct kref		ref;
  };

  #define CREATE_TRACE_POINTS
  #include <trace/events/clk.h>

  struct clk {
  	struct clk_core	*core;

  	struct device *dev;

  	const char *dev_id;
  	const char *con_id;

  	unsigned long min_rate;
  	unsigned long max_rate;

  	unsigned int exclusive_count;

  	struct hlist_node clks_node;

  };

  /***           runtime pm          ***/
  static int clk_pm_runtime_get(struct clk_core *core)
  {

  	int ret;

  	if (!core->rpm_enabled)

  		return 0;
  
  	ret = pm_runtime_get_sync(core->dev);
  	return ret < 0 ? ret : 0;
  }
  
  static void clk_pm_runtime_put(struct clk_core *core)
  {

  	if (!core->rpm_enabled)

  		return;
  
  	pm_runtime_put_sync(core->dev);
  }

  /***           locking             ***/
  static void clk_prepare_lock(void)
  {

  	if (!mutex_trylock(&prepare_lock)) {
  		if (prepare_owner == current) {
  			prepare_refcnt++;
  			return;
  		}
  		mutex_lock(&prepare_lock);
  	}
  	WARN_ON_ONCE(prepare_owner != NULL);
  	WARN_ON_ONCE(prepare_refcnt != 0);
  	prepare_owner = current;
  	prepare_refcnt = 1;

  }
  
  static void clk_prepare_unlock(void)
  {

  	WARN_ON_ONCE(prepare_owner != current);
  	WARN_ON_ONCE(prepare_refcnt == 0);
  
  	if (--prepare_refcnt)
  		return;
  	prepare_owner = NULL;

  	mutex_unlock(&prepare_lock);
  }
  
  static unsigned long clk_enable_lock(void)

  	__acquires(enable_lock)

  {
  	unsigned long flags;

  	/*
  	 * On UP systems, spin_trylock_irqsave() always returns true, even if
  	 * we already hold the lock. So, in that case, we rely only on
  	 * reference counting.
  	 */
  	if (!IS_ENABLED(CONFIG_SMP) ||
  	    !spin_trylock_irqsave(&enable_lock, flags)) {

  		if (enable_owner == current) {
  			enable_refcnt++;

  			__acquire(enable_lock);

  			if (!IS_ENABLED(CONFIG_SMP))
  				local_save_flags(flags);

  			return flags;
  		}
  		spin_lock_irqsave(&enable_lock, flags);
  	}
  	WARN_ON_ONCE(enable_owner != NULL);
  	WARN_ON_ONCE(enable_refcnt != 0);
  	enable_owner = current;
  	enable_refcnt = 1;

  	return flags;
  }
  
  static void clk_enable_unlock(unsigned long flags)

  	__releases(enable_lock)

  {

  	WARN_ON_ONCE(enable_owner != current);
  	WARN_ON_ONCE(enable_refcnt == 0);

  	if (--enable_refcnt) {
  		__release(enable_lock);

  		return;

  	}

  	enable_owner = NULL;

  	spin_unlock_irqrestore(&enable_lock, flags);
  }

  static bool clk_core_rate_is_protected(struct clk_core *core)
  {
  	return core->protect_count;
  }

  static bool clk_core_is_prepared(struct clk_core *core)
  {

  	bool ret = false;

  	/*
  	 * .is_prepared is optional for clocks that can prepare
  	 * fall back to software usage counter if it is missing
  	 */
  	if (!core->ops->is_prepared)
  		return core->prepare_count;

  	if (!clk_pm_runtime_get(core)) {
  		ret = core->ops->is_prepared(core->hw);
  		clk_pm_runtime_put(core);
  	}
  
  	return ret;

  }

  static bool clk_core_is_enabled(struct clk_core *core)
  {

  	bool ret = false;

  	/*
  	 * .is_enabled is only mandatory for clocks that gate
  	 * fall back to software usage counter if .is_enabled is missing
  	 */
  	if (!core->ops->is_enabled)
  		return core->enable_count;

  	/*
  	 * Check if clock controller's device is runtime active before
  	 * calling .is_enabled callback. If not, assume that clock is
  	 * disabled, because we might be called from atomic context, from
  	 * which pm_runtime_get() is not allowed.
  	 * This function is called mainly from clk_disable_unused_subtree,
  	 * which ensures proper runtime pm activation of controller before
  	 * taking enable spinlock, but the below check is needed if one tries
  	 * to call it from other places.
  	 */

  	if (core->rpm_enabled) {

  		pm_runtime_get_noresume(core->dev);
  		if (!pm_runtime_active(core->dev)) {
  			ret = false;
  			goto done;
  		}
  	}
  
  	ret = core->ops->is_enabled(core->hw);
  done:

  	if (core->rpm_enabled)

  		pm_runtime_put(core->dev);

  
  	return ret;

  }

  /***    helper functions   ***/

  const char *__clk_get_name(const struct clk *clk)

  {

  	return !clk ? NULL : clk->core->name;

  }

  EXPORT_SYMBOL_GPL(__clk_get_name);

  const char *clk_hw_get_name(const struct clk_hw *hw)

  {
  	return hw->core->name;
  }
  EXPORT_SYMBOL_GPL(clk_hw_get_name);

  struct clk_hw *__clk_get_hw(struct clk *clk)
  {
  	return !clk ? NULL : clk->core->hw;
  }
  EXPORT_SYMBOL_GPL(__clk_get_hw);

  unsigned int clk_hw_get_num_parents(const struct clk_hw *hw)

  {
  	return hw->core->num_parents;
  }
  EXPORT_SYMBOL_GPL(clk_hw_get_num_parents);

  struct clk_hw *clk_hw_get_parent(const struct clk_hw *hw)

  {
  	return hw->core->parent ? hw->core->parent->hw : NULL;
  }
  EXPORT_SYMBOL_GPL(clk_hw_get_parent);

  static struct clk_core *__clk_lookup_subtree(const char *name,
  					     struct clk_core *core)

  {

  	struct clk_core *child;

  	struct clk_core *ret;

  	if (!strcmp(core->name, name))
  		return core;

  	hlist_for_each_entry(child, &core->children, child_node) {
  		ret = __clk_lookup_subtree(name, child);
  		if (ret)
  			return ret;

  	}

  	return NULL;

  }

  static struct clk_core *clk_core_lookup(const char *name)

  {

  	struct clk_core *root_clk;
  	struct clk_core *ret;

  	if (!name)
  		return NULL;

  	/* search the 'proper' clk tree first */
  	hlist_for_each_entry(root_clk, &clk_root_list, child_node) {
  		ret = __clk_lookup_subtree(name, root_clk);
  		if (ret)
  			return ret;

  	}

  	/* if not found, then search the orphan tree */
  	hlist_for_each_entry(root_clk, &clk_orphan_list, child_node) {
  		ret = __clk_lookup_subtree(name, root_clk);
  		if (ret)
  			return ret;
  	}

  	return NULL;

  }

  #ifdef CONFIG_OF
  static int of_parse_clkspec(const struct device_node *np, int index,
  			    const char *name, struct of_phandle_args *out_args);
  static struct clk_hw *
  of_clk_get_hw_from_clkspec(struct of_phandle_args *clkspec);
  #else
  static inline int of_parse_clkspec(const struct device_node *np, int index,
  				   const char *name,
  				   struct of_phandle_args *out_args)
  {
  	return -ENOENT;
  }
  static inline struct clk_hw *
  of_clk_get_hw_from_clkspec(struct of_phandle_args *clkspec)
  {
  	return ERR_PTR(-ENOENT);
  }
  #endif

  /**

   * clk_core_get - Find the clk_core parent of a clk

   * @core: clk to find parent of

   * @p_index: parent index to search for

   *
   * This is the preferred method for clk providers to find the parent of a
   * clk when that parent is external to the clk controller. The parent_names
   * array is indexed and treated as a local name matching a string in the device

   * node's 'clock-names' property or as the 'con_id' matching the device's
   * dev_name() in a clk_lookup. This allows clk providers to use their own

   * namespace instead of looking for a globally unique parent string.
   *
   * For example the following DT snippet would allow a clock registered by the
   * clock-controller@c001 that has a clk_init_data::parent_data array
   * with 'xtal' in the 'name' member to find the clock provided by the
   * clock-controller@f00abcd without needing to get the globally unique name of
   * the xtal clk.
   *
   *      parent: clock-controller@f00abcd {
   *              reg = <0xf00abcd 0xabcd>;
   *              #clock-cells = <0>;
   *      };
   *
   *      clock-controller@c001 {
   *              reg = <0xc001 0xf00d>;
   *              clocks = <&parent>;
   *              clock-names = "xtal";
   *              #clock-cells = <1>;
   *      };
   *
   * Returns: -ENOENT when the provider can't be found or the clk doesn't

   * exist in the provider or the name can't be found in the DT node or
   * in a clkdev lookup. NULL when the provider knows about the clk but it
   * isn't provided on this system.

   * A valid clk_core pointer when the clk can be found in the provider.
   */

  static struct clk_core *clk_core_get(struct clk_core *core, u8 p_index)

  {

  	const char *name = core->parents[p_index].fw_name;
  	int index = core->parents[p_index].index;

  	struct clk_hw *hw = ERR_PTR(-ENOENT);
  	struct device *dev = core->dev;
  	const char *dev_id = dev ? dev_name(dev) : NULL;

  	struct device_node *np = core->of_node;

  	struct of_phandle_args clkspec;

  	if (np && (name || index >= 0) &&
  	    !of_parse_clkspec(np, index, name, &clkspec)) {
  		hw = of_clk_get_hw_from_clkspec(&clkspec);
  		of_node_put(clkspec.np);
  	} else if (name) {
  		/*
  		 * If the DT search above couldn't find the provider fallback to
  		 * looking up via clkdev based clk_lookups.
  		 */

  		hw = clk_find_hw(dev_id, name);

  	}

  
  	if (IS_ERR(hw))

  		return ERR_CAST(hw);
  
  	return hw->core;
  }
  
  static void clk_core_fill_parent_index(struct clk_core *core, u8 index)
  {
  	struct clk_parent_map *entry = &core->parents[index];
  	struct clk_core *parent = ERR_PTR(-ENOENT);
  
  	if (entry->hw) {
  		parent = entry->hw->core;
  		/*
  		 * We have a direct reference but it isn't registered yet?
  		 * Orphan it and let clk_reparent() update the orphan status
  		 * when the parent is registered.
  		 */
  		if (!parent)
  			parent = ERR_PTR(-EPROBE_DEFER);
  	} else {

  		parent = clk_core_get(core, index);

  		if (IS_ERR(parent) && PTR_ERR(parent) == -ENOENT && entry->name)

  			parent = clk_core_lookup(entry->name);
  	}
  
  	/* Only cache it if it's not an error */
  	if (!IS_ERR(parent))
  		entry->core = parent;
  }

  static struct clk_core *clk_core_get_parent_by_index(struct clk_core *core,
  							 u8 index)

  {

  	if (!core || index >= core->num_parents || !core->parents)

  		return NULL;

  	if (!core->parents[index].core)
  		clk_core_fill_parent_index(core, index);

  	return core->parents[index].core;

  }

  struct clk_hw *
  clk_hw_get_parent_by_index(const struct clk_hw *hw, unsigned int index)

  {
  	struct clk_core *parent;
  
  	parent = clk_core_get_parent_by_index(hw->core, index);
  
  	return !parent ? NULL : parent->hw;
  }
  EXPORT_SYMBOL_GPL(clk_hw_get_parent_by_index);

  unsigned int __clk_get_enable_count(struct clk *clk)
  {
  	return !clk ? 0 : clk->core->enable_count;
  }

  static unsigned long clk_core_get_rate_nolock(struct clk_core *core)
  {

  	if (!core)
  		return 0;

  	if (!core->num_parents || core->parent)
  		return core->rate;

  	/*
  	 * Clk must have a parent because num_parents > 0 but the parent isn't
  	 * known yet. Best to return 0 as the rate of this clk until we can
  	 * properly recalc the rate based on the parent's rate.
  	 */
  	return 0;

  }

  unsigned long clk_hw_get_rate(const struct clk_hw *hw)

  {
  	return clk_core_get_rate_nolock(hw->core);
  }
  EXPORT_SYMBOL_GPL(clk_hw_get_rate);

  static unsigned long __clk_get_accuracy(struct clk_core *core)
  {
  	if (!core)
  		return 0;

  	return core->accuracy;

  }

  unsigned long __clk_get_flags(struct clk *clk)

  {

  	return !clk ? 0 : clk->core->flags;

  }

  EXPORT_SYMBOL_GPL(__clk_get_flags);

  unsigned long clk_hw_get_flags(const struct clk_hw *hw)

  {
  	return hw->core->flags;
  }
  EXPORT_SYMBOL_GPL(clk_hw_get_flags);

  bool clk_hw_is_prepared(const struct clk_hw *hw)

  {
  	return clk_core_is_prepared(hw->core);
  }

  EXPORT_SYMBOL_GPL(clk_hw_is_prepared);

  bool clk_hw_rate_is_protected(const struct clk_hw *hw)
  {
  	return clk_core_rate_is_protected(hw->core);
  }

  EXPORT_SYMBOL_GPL(clk_hw_rate_is_protected);

  bool clk_hw_is_enabled(const struct clk_hw *hw)
  {
  	return clk_core_is_enabled(hw->core);
  }

  EXPORT_SYMBOL_GPL(clk_hw_is_enabled);

  bool __clk_is_enabled(struct clk *clk)

  {

  	if (!clk)
  		return false;

  	return clk_core_is_enabled(clk->core);
  }
  EXPORT_SYMBOL_GPL(__clk_is_enabled);

  static bool mux_is_better_rate(unsigned long rate, unsigned long now,
  			   unsigned long best, unsigned long flags)
  {
  	if (flags & CLK_MUX_ROUND_CLOSEST)
  		return abs(now - rate) < abs(best - rate);

  	return now <= rate && now > best;
  }

  int clk_mux_determine_rate_flags(struct clk_hw *hw,
  				 struct clk_rate_request *req,
  				 unsigned long flags)

  {
  	struct clk_core *core = hw->core, *parent, *best_parent = NULL;

  	int i, num_parents, ret;
  	unsigned long best = 0;
  	struct clk_rate_request parent_req = *req;

  	/* if NO_REPARENT flag set, pass through to current parent */
  	if (core->flags & CLK_SET_RATE_NO_REPARENT) {
  		parent = core->parent;

  		if (core->flags & CLK_SET_RATE_PARENT) {
  			ret = __clk_determine_rate(parent ? parent->hw : NULL,
  						   &parent_req);
  			if (ret)
  				return ret;
  
  			best = parent_req.rate;
  		} else if (parent) {

  			best = clk_core_get_rate_nolock(parent);

  		} else {

  			best = clk_core_get_rate_nolock(core);

  		}

  		goto out;
  	}

  	/* find the parent that can provide the fastest rate <= rate */
  	num_parents = core->num_parents;
  	for (i = 0; i < num_parents; i++) {
  		parent = clk_core_get_parent_by_index(core, i);
  		if (!parent)
  			continue;

  
  		if (core->flags & CLK_SET_RATE_PARENT) {
  			parent_req = *req;
  			ret = __clk_determine_rate(parent->hw, &parent_req);
  			if (ret)
  				continue;
  		} else {
  			parent_req.rate = clk_core_get_rate_nolock(parent);
  		}
  
  		if (mux_is_better_rate(req->rate, parent_req.rate,
  				       best, flags)) {

  			best_parent = parent;

  			best = parent_req.rate;

  		}
  	}

  	if (!best_parent)
  		return -EINVAL;

  out:
  	if (best_parent)

  		req->best_parent_hw = best_parent->hw;
  	req->best_parent_rate = best;
  	req->rate = best;

  	return 0;

  }

  EXPORT_SYMBOL_GPL(clk_mux_determine_rate_flags);

  
  struct clk *__clk_lookup(const char *name)

  {

  	struct clk_core *core = clk_core_lookup(name);
  
  	return !core ? NULL : core->hw->clk;

  }

  static void clk_core_get_boundaries(struct clk_core *core,
  				    unsigned long *min_rate,
  				    unsigned long *max_rate)

  {

  	struct clk *clk_user;

  	lockdep_assert_held(&prepare_lock);

  	*min_rate = core->min_rate;
  	*max_rate = core->max_rate;

  	hlist_for_each_entry(clk_user, &core->clks, clks_node)
  		*min_rate = max(*min_rate, clk_user->min_rate);

  	hlist_for_each_entry(clk_user, &core->clks, clks_node)
  		*max_rate = min(*max_rate, clk_user->max_rate);
  }

  void clk_hw_set_rate_range(struct clk_hw *hw, unsigned long min_rate,
  			   unsigned long max_rate)
  {
  	hw->core->min_rate = min_rate;
  	hw->core->max_rate = max_rate;
  }
  EXPORT_SYMBOL_GPL(clk_hw_set_rate_range);

  /*

   * __clk_mux_determine_rate - clk_ops::determine_rate implementation for a mux type clk
   * @hw: mux type clk to determine rate on
   * @req: rate request, also used to return preferred parent and frequencies
   *

   * Helper for finding best parent to provide a given frequency. This can be used
   * directly as a determine_rate callback (e.g. for a mux), or from a more
   * complex clock that may combine a mux with other operations.

   *
   * Returns: 0 on success, -EERROR value on error

   */

  int __clk_mux_determine_rate(struct clk_hw *hw,
  			     struct clk_rate_request *req)

  {

  	return clk_mux_determine_rate_flags(hw, req, 0);

  }

  EXPORT_SYMBOL_GPL(__clk_mux_determine_rate);

  int __clk_mux_determine_rate_closest(struct clk_hw *hw,
  				     struct clk_rate_request *req)

  {

  	return clk_mux_determine_rate_flags(hw, req, CLK_MUX_ROUND_CLOSEST);

  }
  EXPORT_SYMBOL_GPL(__clk_mux_determine_rate_closest);

  /***        clk api        ***/

  static void clk_core_rate_unprotect(struct clk_core *core)
  {
  	lockdep_assert_held(&prepare_lock);
  
  	if (!core)
  		return;

  	if (WARN(core->protect_count == 0,
  	    "%s already unprotected
  ", core->name))

  		return;
  
  	if (--core->protect_count > 0)
  		return;
  
  	clk_core_rate_unprotect(core->parent);
  }
  
  static int clk_core_rate_nuke_protect(struct clk_core *core)
  {
  	int ret;
  
  	lockdep_assert_held(&prepare_lock);
  
  	if (!core)
  		return -EINVAL;
  
  	if (core->protect_count == 0)
  		return 0;
  
  	ret = core->protect_count;
  	core->protect_count = 1;
  	clk_core_rate_unprotect(core);
  
  	return ret;
  }

  /**
   * clk_rate_exclusive_put - release exclusivity over clock rate control
   * @clk: the clk over which the exclusivity is released
   *
   * clk_rate_exclusive_put() completes a critical section during which a clock
   * consumer cannot tolerate any other consumer making any operation on the
   * clock which could result in a rate change or rate glitch. Exclusive clocks
   * cannot have their rate changed, either directly or indirectly due to changes
   * further up the parent chain of clocks. As a result, clocks up parent chain
   * also get under exclusive control of the calling consumer.
   *
   * If exlusivity is claimed more than once on clock, even by the same consumer,
   * the rate effectively gets locked as exclusivity can't be preempted.
   *
   * Calls to clk_rate_exclusive_put() must be balanced with calls to
   * clk_rate_exclusive_get(). Calls to this function may sleep, and do not return
   * error status.
   */
  void clk_rate_exclusive_put(struct clk *clk)
  {
  	if (!clk)
  		return;
  
  	clk_prepare_lock();
  
  	/*
  	 * if there is something wrong with this consumer protect count, stop
  	 * here before messing with the provider
  	 */
  	if (WARN_ON(clk->exclusive_count <= 0))
  		goto out;
  
  	clk_core_rate_unprotect(clk->core);
  	clk->exclusive_count--;
  out:
  	clk_prepare_unlock();
  }
  EXPORT_SYMBOL_GPL(clk_rate_exclusive_put);

  static void clk_core_rate_protect(struct clk_core *core)
  {
  	lockdep_assert_held(&prepare_lock);
  
  	if (!core)
  		return;
  
  	if (core->protect_count == 0)
  		clk_core_rate_protect(core->parent);
  
  	core->protect_count++;
  }
  
  static void clk_core_rate_restore_protect(struct clk_core *core, int count)
  {
  	lockdep_assert_held(&prepare_lock);
  
  	if (!core)
  		return;
  
  	if (count == 0)
  		return;
  
  	clk_core_rate_protect(core);
  	core->protect_count = count;
  }

  /**
   * clk_rate_exclusive_get - get exclusivity over the clk rate control
   * @clk: the clk over which the exclusity of rate control is requested
   *
   * clk_rate_exlusive_get() begins a critical section during which a clock
   * consumer cannot tolerate any other consumer making any operation on the
   * clock which could result in a rate change or rate glitch. Exclusive clocks
   * cannot have their rate changed, either directly or indirectly due to changes
   * further up the parent chain of clocks. As a result, clocks up parent chain
   * also get under exclusive control of the calling consumer.
   *
   * If exlusivity is claimed more than once on clock, even by the same consumer,
   * the rate effectively gets locked as exclusivity can't be preempted.
   *
   * Calls to clk_rate_exclusive_get() should be balanced with calls to
   * clk_rate_exclusive_put(). Calls to this function may sleep.
   * Returns 0 on success, -EERROR otherwise
   */
  int clk_rate_exclusive_get(struct clk *clk)
  {
  	if (!clk)
  		return 0;
  
  	clk_prepare_lock();
  	clk_core_rate_protect(clk->core);
  	clk->exclusive_count++;
  	clk_prepare_unlock();
  
  	return 0;
  }
  EXPORT_SYMBOL_GPL(clk_rate_exclusive_get);

  static void clk_core_unprepare(struct clk_core *core)
  {

  	lockdep_assert_held(&prepare_lock);

  	if (!core)
  		return;

  	if (WARN(core->prepare_count == 0,
  	    "%s already unprepared
  ", core->name))

  		return;

  	if (WARN(core->prepare_count == 1 && core->flags & CLK_IS_CRITICAL,
  	    "Unpreparing critical %s
  ", core->name))

  		return;

  	if (core->flags & CLK_SET_RATE_GATE)
  		clk_core_rate_unprotect(core);

  	if (--core->prepare_count > 0)
  		return;

  	WARN(core->enable_count > 0, "Unpreparing enabled %s
  ", core->name);

  	trace_clk_unprepare(core);

  	if (core->ops->unprepare)
  		core->ops->unprepare(core->hw);

  	clk_pm_runtime_put(core);

  	trace_clk_unprepare_complete(core);
  	clk_core_unprepare(core->parent);

  }

  static void clk_core_unprepare_lock(struct clk_core *core)
  {
  	clk_prepare_lock();
  	clk_core_unprepare(core);
  	clk_prepare_unlock();
  }

  /**
   * clk_unprepare - undo preparation of a clock source
   * @clk: the clk being unprepared
   *
   * clk_unprepare may sleep, which differentiates it from clk_disable.  In a
   * simple case, clk_unprepare can be used instead of clk_disable to gate a clk
   * if the operation may sleep.  One example is a clk which is accessed over
   * I2c.  In the complex case a clk gate operation may require a fast and a slow
   * part.  It is this reason that clk_unprepare and clk_disable are not mutually
   * exclusive.  In fact clk_disable must be called before clk_unprepare.
   */
  void clk_unprepare(struct clk *clk)

  {

  	if (IS_ERR_OR_NULL(clk))
  		return;

  	clk_core_unprepare_lock(clk->core);

  }

  EXPORT_SYMBOL_GPL(clk_unprepare);

  static int clk_core_prepare(struct clk_core *core)

  {

  	int ret = 0;

  	lockdep_assert_held(&prepare_lock);

  	if (!core)

  		return 0;

  	if (core->prepare_count == 0) {

  		ret = clk_pm_runtime_get(core);

  		if (ret)
  			return ret;

  		ret = clk_core_prepare(core->parent);
  		if (ret)
  			goto runtime_put;

  		trace_clk_prepare(core);

  		if (core->ops->prepare)
  			ret = core->ops->prepare(core->hw);

  		trace_clk_prepare_complete(core);

  		if (ret)
  			goto unprepare;

  	}

  	core->prepare_count++;

  	/*
  	 * CLK_SET_RATE_GATE is a special case of clock protection
  	 * Instead of a consumer claiming exclusive rate control, it is
  	 * actually the provider which prevents any consumer from making any
  	 * operation which could result in a rate change or rate glitch while
  	 * the clock is prepared.
  	 */
  	if (core->flags & CLK_SET_RATE_GATE)
  		clk_core_rate_protect(core);

  	return 0;

  unprepare:
  	clk_core_unprepare(core->parent);
  runtime_put:
  	clk_pm_runtime_put(core);
  	return ret;

  }

  static int clk_core_prepare_lock(struct clk_core *core)
  {
  	int ret;
  
  	clk_prepare_lock();
  	ret = clk_core_prepare(core);
  	clk_prepare_unlock();
  
  	return ret;
  }

  /**
   * clk_prepare - prepare a clock source
   * @clk: the clk being prepared
   *
   * clk_prepare may sleep, which differentiates it from clk_enable.  In a simple
   * case, clk_prepare can be used instead of clk_enable to ungate a clk if the
   * operation may sleep.  One example is a clk which is accessed over I2c.  In
   * the complex case a clk ungate operation may require a fast and a slow part.
   * It is this reason that clk_prepare and clk_enable are not mutually
   * exclusive.  In fact clk_prepare must be called before clk_enable.
   * Returns 0 on success, -EERROR otherwise.
   */
  int clk_prepare(struct clk *clk)

  {

  	if (!clk)
  		return 0;

  	return clk_core_prepare_lock(clk->core);

  }

  EXPORT_SYMBOL_GPL(clk_prepare);

  static void clk_core_disable(struct clk_core *core)

  {

  	lockdep_assert_held(&enable_lock);

  	if (!core)
  		return;

  	if (WARN(core->enable_count == 0, "%s already disabled
  ", core->name))

  		return;

  	if (WARN(core->enable_count == 1 && core->flags & CLK_IS_CRITICAL,
  	    "Disabling critical %s
  ", core->name))

  		return;

  	if (--core->enable_count > 0)
  		return;

  	trace_clk_disable_rcuidle(core);

  	if (core->ops->disable)
  		core->ops->disable(core->hw);

  	trace_clk_disable_complete_rcuidle(core);

  	clk_core_disable(core->parent);

  }

  static void clk_core_disable_lock(struct clk_core *core)
  {
  	unsigned long flags;
  
  	flags = clk_enable_lock();
  	clk_core_disable(core);
  	clk_enable_unlock(flags);
  }

  /**
   * clk_disable - gate a clock
   * @clk: the clk being gated
   *
   * clk_disable must not sleep, which differentiates it from clk_unprepare.  In
   * a simple case, clk_disable can be used instead of clk_unprepare to gate a
   * clk if the operation is fast and will never sleep.  One example is a
   * SoC-internal clk which is controlled via simple register writes.  In the
   * complex case a clk gate operation may require a fast and a slow part.  It is
   * this reason that clk_unprepare and clk_disable are not mutually exclusive.
   * In fact clk_disable must be called before clk_unprepare.
   */
  void clk_disable(struct clk *clk)

  {

  	if (IS_ERR_OR_NULL(clk))
  		return;

  	clk_core_disable_lock(clk->core);

  }

  EXPORT_SYMBOL_GPL(clk_disable);

  static int clk_core_enable(struct clk_core *core)

  {

  	int ret = 0;

  	lockdep_assert_held(&enable_lock);

  	if (!core)
  		return 0;

  	if (WARN(core->prepare_count == 0,
  	    "Enabling unprepared %s
  ", core->name))

  		return -ESHUTDOWN;

  	if (core->enable_count == 0) {
  		ret = clk_core_enable(core->parent);

  		if (ret)
  			return ret;

  		trace_clk_enable_rcuidle(core);

  		if (core->ops->enable)
  			ret = core->ops->enable(core->hw);

  		trace_clk_enable_complete_rcuidle(core);

  
  		if (ret) {
  			clk_core_disable(core->parent);
  			return ret;
  		}
  	}
  
  	core->enable_count++;
  	return 0;

  }

  static int clk_core_enable_lock(struct clk_core *core)
  {
  	unsigned long flags;
  	int ret;
  
  	flags = clk_enable_lock();
  	ret = clk_core_enable(core);
  	clk_enable_unlock(flags);
  
  	return ret;
  }

  /**
   * clk_gate_restore_context - restore context for poweroff
   * @hw: the clk_hw pointer of clock whose state is to be restored
   *
   * The clock gate restore context function enables or disables
   * the gate clocks based on the enable_count. This is done in cases
   * where the clock context is lost and based on the enable_count
   * the clock either needs to be enabled/disabled. This
   * helps restore the state of gate clocks.
   */
  void clk_gate_restore_context(struct clk_hw *hw)
  {

  	struct clk_core *core = hw->core;
  
  	if (core->enable_count)
  		core->ops->enable(hw);

  	else

  		core->ops->disable(hw);

  }
  EXPORT_SYMBOL_GPL(clk_gate_restore_context);

  static int clk_core_save_context(struct clk_core *core)

  {
  	struct clk_core *child;
  	int ret = 0;

  	hlist_for_each_entry(child, &core->children, child_node) {
  		ret = clk_core_save_context(child);

  		if (ret < 0)
  			return ret;
  	}

  	if (core->ops && core->ops->save_context)
  		ret = core->ops->save_context(core->hw);

  
  	return ret;
  }

  static void clk_core_restore_context(struct clk_core *core)

  {
  	struct clk_core *child;

  	if (core->ops && core->ops->restore_context)
  		core->ops->restore_context(core->hw);

  	hlist_for_each_entry(child, &core->children, child_node)
  		clk_core_restore_context(child);

  }
  
  /**
   * clk_save_context - save clock context for poweroff
   *
   * Saves the context of the clock register for powerstates in which the
   * contents of the registers will be lost. Occurs deep within the suspend
   * code.  Returns 0 on success.
   */
  int clk_save_context(void)
  {
  	struct clk_core *clk;
  	int ret;
  
  	hlist_for_each_entry(clk, &clk_root_list, child_node) {

  		ret = clk_core_save_context(clk);

  		if (ret < 0)
  			return ret;
  	}
  
  	hlist_for_each_entry(clk, &clk_orphan_list, child_node) {

  		ret = clk_core_save_context(clk);

  		if (ret < 0)
  			return ret;
  	}
  
  	return 0;
  }
  EXPORT_SYMBOL_GPL(clk_save_context);
  
  /**
   * clk_restore_context - restore clock context after poweroff
   *
   * Restore the saved clock context upon resume.
   *
   */
  void clk_restore_context(void)
  {

  	struct clk_core *core;

  	hlist_for_each_entry(core, &clk_root_list, child_node)
  		clk_core_restore_context(core);

  	hlist_for_each_entry(core, &clk_orphan_list, child_node)
  		clk_core_restore_context(core);

  }
  EXPORT_SYMBOL_GPL(clk_restore_context);

  /**
   * clk_enable - ungate a clock
   * @clk: the clk being ungated
   *
   * clk_enable must not sleep, which differentiates it from clk_prepare.  In a
   * simple case, clk_enable can be used instead of clk_prepare to ungate a clk
   * if the operation will never sleep.  One example is a SoC-internal clk which
   * is controlled via simple register writes.  In the complex case a clk ungate
   * operation may require a fast and a slow part.  It is this reason that
   * clk_enable and clk_prepare are not mutually exclusive.  In fact clk_prepare
   * must be called before clk_enable.  Returns 0 on success, -EERROR
   * otherwise.
   */
  int clk_enable(struct clk *clk)

  {

  	if (!clk)

  		return 0;

  	return clk_core_enable_lock(clk->core);
  }
  EXPORT_SYMBOL_GPL(clk_enable);
  
  static int clk_core_prepare_enable(struct clk_core *core)
  {
  	int ret;
  
  	ret = clk_core_prepare_lock(core);
  	if (ret)
  		return ret;
  
  	ret = clk_core_enable_lock(core);
  	if (ret)
  		clk_core_unprepare_lock(core);

  	return ret;

  }

  
  static void clk_core_disable_unprepare(struct clk_core *core)
  {
  	clk_core_disable_lock(core);
  	clk_core_unprepare_lock(core);
  }

  static void clk_unprepare_unused_subtree(struct clk_core *core)
  {
  	struct clk_core *child;
  
  	lockdep_assert_held(&prepare_lock);
  
  	hlist_for_each_entry(child, &core->children, child_node)
  		clk_unprepare_unused_subtree(child);
  
  	if (core->prepare_count)
  		return;
  
  	if (core->flags & CLK_IGNORE_UNUSED)
  		return;

  	if (clk_pm_runtime_get(core))
  		return;

  	if (clk_core_is_prepared(core)) {
  		trace_clk_unprepare(core);
  		if (core->ops->unprepare_unused)
  			core->ops->unprepare_unused(core->hw);
  		else if (core->ops->unprepare)
  			core->ops->unprepare(core->hw);
  		trace_clk_unprepare_complete(core);
  	}

  
  	clk_pm_runtime_put(core);

  }
  
  static void clk_disable_unused_subtree(struct clk_core *core)
  {
  	struct clk_core *child;
  	unsigned long flags;
  
  	lockdep_assert_held(&prepare_lock);
  
  	hlist_for_each_entry(child, &core->children, child_node)
  		clk_disable_unused_subtree(child);

  	if (core->flags & CLK_OPS_PARENT_ENABLE)
  		clk_core_prepare_enable(core->parent);

  	if (clk_pm_runtime_get(core))
  		goto unprepare_out;

  	flags = clk_enable_lock();
  
  	if (core->enable_count)
  		goto unlock_out;
  
  	if (core->flags & CLK_IGNORE_UNUSED)
  		goto unlock_out;
  
  	/*
  	 * some gate clocks have special needs during the disable-unused
  	 * sequence.  call .disable_unused if available, otherwise fall
  	 * back to .disable
  	 */
  	if (clk_core_is_enabled(core)) {
  		trace_clk_disable(core);
  		if (core->ops->disable_unused)
  			core->ops->disable_unused(core->hw);
  		else if (core->ops->disable)
  			core->ops->disable(core->hw);
  		trace_clk_disable_complete(core);
  	}
  
  unlock_out:
  	clk_enable_unlock(flags);

  	clk_pm_runtime_put(core);
  unprepare_out:

  	if (core->flags & CLK_OPS_PARENT_ENABLE)
  		clk_core_disable_unprepare(core->parent);

  }
  
  static bool clk_ignore_unused;
  static int __init clk_ignore_unused_setup(char *__unused)
  {
  	clk_ignore_unused = true;
  	return 1;
  }
  __setup("clk_ignore_unused", clk_ignore_unused_setup);
  
  static int clk_disable_unused(void)
  {
  	struct clk_core *core;
  
  	if (clk_ignore_unused) {
  		pr_warn("clk: Not disabling unused clocks
  ");
  		return 0;
  	}
  
  	clk_prepare_lock();
  
  	hlist_for_each_entry(core, &clk_root_list, child_node)
  		clk_disable_unused_subtree(core);
  
  	hlist_for_each_entry(core, &clk_orphan_list, child_node)
  		clk_disable_unused_subtree(core);
  
  	hlist_for_each_entry(core, &clk_root_list, child_node)
  		clk_unprepare_unused_subtree(core);
  
  	hlist_for_each_entry(core, &clk_orphan_list, child_node)
  		clk_unprepare_unused_subtree(core);
  
  	clk_prepare_unlock();
  
  	return 0;
  }
  late_initcall_sync(clk_disable_unused);

  static int clk_core_determine_round_nolock(struct clk_core *core,
  					   struct clk_rate_request *req)

  {

  	long rate;

  
  	lockdep_assert_held(&prepare_lock);

  	if (!core)

  		return 0;

  	/*
  	 * At this point, core protection will be disabled if
  	 * - if the provider is not protected at all
  	 * - if the calling consumer is the only one which has exclusivity
  	 *   over the provider
  	 */

  	if (clk_core_rate_is_protected(core)) {
  		req->rate = core->rate;
  	} else if (core->ops->determine_rate) {

  		return core->ops->determine_rate(core->hw, req);
  	} else if (core->ops->round_rate) {
  		rate = core->ops->round_rate(core->hw, req->rate,
  					     &req->best_parent_rate);
  		if (rate < 0)
  			return rate;
  
  		req->rate = rate;

  	} else {

  		return -EINVAL;

  	}
  
  	return 0;

  }

  static void clk_core_init_rate_req(struct clk_core * const core,
  				   struct clk_rate_request *req)
  {
  	struct clk_core *parent;
  
  	if (WARN_ON(!core || !req))
  		return;
  
  	parent = core->parent;
  	if (parent) {
  		req->best_parent_hw = parent->hw;
  		req->best_parent_rate = parent->rate;
  	} else {
  		req->best_parent_hw = NULL;
  		req->best_parent_rate = 0;

  	}

  }

  static bool clk_core_can_round(struct clk_core * const core)
  {

  	return core->ops->determine_rate || core->ops->round_rate;

  }
  
  static int clk_core_round_rate_nolock(struct clk_core *core,
  				      struct clk_rate_request *req)
  {
  	lockdep_assert_held(&prepare_lock);

  	if (!core) {
  		req->rate = 0;

  		return 0;

  	}

  	clk_core_init_rate_req(core, req);
  
  	if (clk_core_can_round(core))
  		return clk_core_determine_round_nolock(core, req);
  	else if (core->flags & CLK_SET_RATE_PARENT)
  		return clk_core_round_rate_nolock(core->parent, req);
  
  	req->rate = core->rate;

  	return 0;

  }

  /**
   * __clk_determine_rate - get the closest rate actually supported by a clock
   * @hw: determine the rate of this clock

   * @req: target rate request

   *

   * Useful for clk_ops such as .set_rate and .determine_rate.

   */

  int __clk_determine_rate(struct clk_hw *hw, struct clk_rate_request *req)

  {

  	if (!hw) {
  		req->rate = 0;

  		return 0;

  	}

  	return clk_core_round_rate_nolock(hw->core, req);

  }

  EXPORT_SYMBOL_GPL(__clk_determine_rate);

  unsigned long clk_hw_round_rate(struct clk_hw *hw, unsigned long rate)
  {
  	int ret;
  	struct clk_rate_request req;
  
  	clk_core_get_boundaries(hw->core, &req.min_rate, &req.max_rate);
  	req.rate = rate;
  
  	ret = clk_core_round_rate_nolock(hw->core, &req);
  	if (ret)
  		return 0;
  
  	return req.rate;
  }
  EXPORT_SYMBOL_GPL(clk_hw_round_rate);

  /**
   * clk_round_rate - round the given rate for a clk
   * @clk: the clk for which we are rounding a rate
   * @rate: the rate which is to be rounded
   *
   * Takes in a rate as input and rounds it to a rate that the clk can actually
   * use which is then returned.  If clk doesn't support round_rate operation
   * then the parent rate is returned.
   */
  long clk_round_rate(struct clk *clk, unsigned long rate)

  {

  	struct clk_rate_request req;
  	int ret;

  	if (!clk)

  		return 0;

  	clk_prepare_lock();

  	if (clk->exclusive_count)
  		clk_core_rate_unprotect(clk->core);

  	clk_core_get_boundaries(clk->core, &req.min_rate, &req.max_rate);
  	req.rate = rate;
  
  	ret = clk_core_round_rate_nolock(clk->core, &req);

  
  	if (clk->exclusive_count)
  		clk_core_rate_protect(clk->core);

  	clk_prepare_unlock();

  	if (ret)
  		return ret;
  
  	return req.rate;

  }

  EXPORT_SYMBOL_GPL(clk_round_rate);

  /**
   * __clk_notify - call clk notifier chain
   * @core: clk that is changing rate
   * @msg: clk notifier type (see include/linux/clk.h)
   * @old_rate: old clk rate
   * @new_rate: new clk rate
   *
   * Triggers a notifier call chain on the clk rate-change notification
   * for 'clk'.  Passes a pointer to the struct clk and the previous
   * and current rates to the notifier callback.  Intended to be called by
   * internal clock code only.  Returns NOTIFY_DONE from the last driver
   * called if all went well, or NOTIFY_STOP or NOTIFY_BAD immediately if
   * a driver returns that.
   */
  static int __clk_notify(struct clk_core *core, unsigned long msg,
  		unsigned long old_rate, unsigned long new_rate)

  {

  	struct clk_notifier *cn;
  	struct clk_notifier_data cnd;
  	int ret = NOTIFY_DONE;

  	cnd.old_rate = old_rate;
  	cnd.new_rate = new_rate;

  	list_for_each_entry(cn, &clk_notifier_list, node) {
  		if (cn->clk->core == core) {
  			cnd.clk = cn->clk;
  			ret = srcu_notifier_call_chain(&cn->notifier_head, msg,
  					&cnd);

  			if (ret & NOTIFY_STOP_MASK)
  				return ret;

  		}

  	}

  	return ret;

  }

  /**
   * __clk_recalc_accuracies
   * @core: first clk in the subtree
   *
   * Walks the subtree of clks starting with clk and recalculates accuracies as
   * it goes.  Note that if a clk does not implement the .recalc_accuracy

   * callback then it is assumed that the clock will take on the accuracy of its

   * parent.

   */
  static void __clk_recalc_accuracies(struct clk_core *core)

  {

  	unsigned long parent_accuracy = 0;
  	struct clk_core *child;

  	lockdep_assert_held(&prepare_lock);

  	if (core->parent)
  		parent_accuracy = core->parent->accuracy;

  	if (core->ops->recalc_accuracy)
  		core->accuracy = core->ops->recalc_accuracy(core->hw,
  							  parent_accuracy);
  	else
  		core->accuracy = parent_accuracy;

  	hlist_for_each_entry(child, &core->children, child_node)
  		__clk_recalc_accuracies(child);

  }

  static long clk_core_get_accuracy(struct clk_core *core)

  {

  	unsigned long accuracy;

  	clk_prepare_lock();
  	if (core && (core->flags & CLK_GET_ACCURACY_NOCACHE))
  		__clk_recalc_accuracies(core);

  	accuracy = __clk_get_accuracy(core);
  	clk_prepare_unlock();

  	return accuracy;

  }

  /**
   * clk_get_accuracy - return the accuracy of clk
   * @clk: the clk whose accuracy is being returned
   *
   * Simply returns the cached accuracy of the clk, unless
   * CLK_GET_ACCURACY_NOCACHE flag is set, which means a recalc_rate will be
   * issued.
   * If clk is NULL then returns 0.
   */
  long clk_get_accuracy(struct clk *clk)

  {

  	if (!clk)
  		return 0;

  	return clk_core_get_accuracy(clk->core);

  }

  EXPORT_SYMBOL_GPL(clk_get_accuracy);

  static unsigned long clk_recalc(struct clk_core *core,
  				unsigned long parent_rate)

  {

  	unsigned long rate = parent_rate;
  
  	if (core->ops->recalc_rate && !clk_pm_runtime_get(core)) {
  		rate = core->ops->recalc_rate(core->hw, parent_rate);
  		clk_pm_runtime_put(core);
  	}
  	return rate;

  }

  /**
   * __clk_recalc_rates
   * @core: first clk in the subtree
   * @msg: notification type (see include/linux/clk.h)
   *
   * Walks the subtree of clks starting with clk and recalculates rates as it
   * goes.  Note that if a clk does not implement the .recalc_rate callback then
   * it is assumed that the clock will take on the rate of its parent.
   *
   * clk_recalc_rates also propagates the POST_RATE_CHANGE notification,
   * if necessary.

   */

  static void __clk_recalc_rates(struct clk_core *core, unsigned long msg)

  {

  	unsigned long old_rate;
  	unsigned long parent_rate = 0;
  	struct clk_core *child;

  	lockdep_assert_held(&prepare_lock);

  	old_rate = core->rate;

  	if (core->parent)
  		parent_rate = core->parent->rate;

  	core->rate = clk_recalc(core, parent_rate);

  	/*
  	 * ignore NOTIFY_STOP and NOTIFY_BAD return values for POST_RATE_CHANGE
  	 * & ABORT_RATE_CHANGE notifiers
  	 */
  	if (core->notifier_count && msg)
  		__clk_notify(core, msg, old_rate, core->rate);

  	hlist_for_each_entry(child, &core->children, child_node)
  		__clk_recalc_rates(child, msg);
  }

  static unsigned long clk_core_get_rate(struct clk_core *core)
  {
  	unsigned long rate;

  	clk_prepare_lock();

  	if (core && (core->flags & CLK_GET_RATE_NOCACHE))
  		__clk_recalc_rates(core, 0);
  
  	rate = clk_core_get_rate_nolock(core);
  	clk_prepare_unlock();
  
  	return rate;

  }
  
  /**

   * clk_get_rate - return the rate of clk
   * @clk: the clk whose rate is being returned

   *

   * Simply returns the cached rate of the clk, unless CLK_GET_RATE_NOCACHE flag
   * is set, which means a recalc_rate will be issued.
   * If clk is NULL then returns 0.

   */

  unsigned long clk_get_rate(struct clk *clk)

  {

  	if (!clk)
  		return 0;

  	return clk_core_get_rate(clk->core);

  }

  EXPORT_SYMBOL_GPL(clk_get_rate);

  static int clk_fetch_parent_index(struct clk_core *core,
  				  struct clk_core *parent)

  {

  	int i;

  	if (!parent)
  		return -EINVAL;

  	for (i = 0; i < core->num_parents; i++) {

  		/* Found it first try! */

  		if (core->parents[i].core == parent)

  			return i;

  		/* Something else is here, so keep looking */

  		if (core->parents[i].core)

  			continue;

  		/* Maybe core hasn't been cached but the hw is all we know? */
  		if (core->parents[i].hw) {
  			if (core->parents[i].hw == parent->hw)
  				break;
  
  			/* Didn't match, but we're expecting a clk_hw */
  			continue;

  		}

  
  		/* Maybe it hasn't been cached (clk_set_parent() path) */
  		if (parent == clk_core_get(core, i))
  			break;
  
  		/* Fallback to comparing globally unique names */

  		if (core->parents[i].name &&
  		    !strcmp(parent->name, core->parents[i].name))

  			break;

  	}

  	if (i == core->num_parents)
  		return -EINVAL;
  
  	core->parents[i].core = parent;
  	return i;

  }

  /*
   * Update the orphan status of @core and all its children.
   */
  static void clk_core_update_orphan_status(struct clk_core *core, bool is_orphan)
  {
  	struct clk_core *child;
  
  	core->orphan = is_orphan;
  
  	hlist_for_each_entry(child, &core->children, child_node)
  		clk_core_update_orphan_status(child, is_orphan);
  }

  static void clk_reparent(struct clk_core *core, struct clk_core *new_parent)

  {

  	bool was_orphan = core->orphan;

  	hlist_del(&core->child_node);

  	if (new_parent) {

  		bool becomes_orphan = new_parent->orphan;

  		/* avoid duplicate POST_RATE_CHANGE notifications */
  		if (new_parent->new_child == core)
  			new_parent->new_child = NULL;

  		hlist_add_head(&core->child_node, &new_parent->children);

  
  		if (was_orphan != becomes_orphan)
  			clk_core_update_orphan_status(core, becomes_orphan);

  	} else {
  		hlist_add_head(&core->child_node, &clk_orphan_list);

  		if (!was_orphan)
  			clk_core_update_orphan_status(core, true);

  	}

  	core->parent = new_parent;

  }

  static struct clk_core *__clk_set_parent_before(struct clk_core *core,
  					   struct clk_core *parent)

  {
  	unsigned long flags;

  	struct clk_core *old_parent = core->parent;

  	/*

  	 * 1. enable parents for CLK_OPS_PARENT_ENABLE clock
  	 *
  	 * 2. Migrate prepare state between parents and prevent race with

  	 * clk_enable().
  	 *
  	 * If the clock is not prepared, then a race with
  	 * clk_enable/disable() is impossible since we already have the
  	 * prepare lock (future calls to clk_enable() need to be preceded by
  	 * a clk_prepare()).
  	 *
  	 * If the clock is prepared, migrate the prepared state to the new
  	 * parent and also protect against a race with clk_enable() by
  	 * forcing the clock and the new parent on.  This ensures that all
  	 * future calls to clk_enable() are practically NOPs with respect to
  	 * hardware and software states.
  	 *
  	 * See also: Comment for clk_set_parent() below.
  	 */

  
  	/* enable old_parent & parent if CLK_OPS_PARENT_ENABLE is set */
  	if (core->flags & CLK_OPS_PARENT_ENABLE) {
  		clk_core_prepare_enable(old_parent);
  		clk_core_prepare_enable(parent);
  	}
  
  	/* migrate prepare count if > 0 */

  	if (core->prepare_count) {

  		clk_core_prepare_enable(parent);
  		clk_core_enable_lock(core);

  	}

  	/* update the clk tree topology */

  	flags = clk_enable_lock();

  	clk_reparent(core, parent);

  	clk_enable_unlock(flags);

  
  	return old_parent;

  }

  static void __clk_set_parent_after(struct clk_core *core,
  				   struct clk_core *parent,
  				   struct clk_core *old_parent)

  {

  	/*
  	 * Finish the migration of prepare state and undo the changes done
  	 * for preventing a race with clk_enable().
  	 */
  	if (core->prepare_count) {

  		clk_core_disable_lock(core);
  		clk_core_disable_unprepare(old_parent);
  	}
  
  	/* re-balance ref counting if CLK_OPS_PARENT_ENABLE is set */
  	if (core->flags & CLK_OPS_PARENT_ENABLE) {
  		clk_core_disable_unprepare(parent);
  		clk_core_disable_unprepare(old_parent);

  	}
  }