/*
   * Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
   * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License version 2 as
   * published by the Free Software Foundation.
   *
   * Standard functionality for the common clock API.  See Documentation/clk.txt
   */

  #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/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);

  /***    private data structures    ***/
  
  struct clk_core {
  	const char		*name;
  	const struct clk_ops	*ops;
  	struct clk_hw		*hw;
  	struct module		*owner;
  	struct clk_core		*parent;
  	const char		**parent_names;
  	struct clk_core		**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;

  	unsigned int		enable_count;
  	unsigned int		prepare_count;

  	unsigned long		min_rate;
  	unsigned long		max_rate;

  	unsigned long		accuracy;
  	int			phase;
  	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;
  	const char *dev_id;
  	const char *con_id;

  	unsigned long min_rate;
  	unsigned long max_rate;

  	struct hlist_node clks_node;

  };

  /***           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;

  
  	if (!spin_trylock_irqsave(&enable_lock, flags)) {
  		if (enable_owner == current) {
  			enable_refcnt++;

  			__acquire(enable_lock);

  			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_is_prepared(struct clk_core *core)
  {
  	/*
  	 * .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;

  	return core->ops->is_prepared(core->hw);
  }

  static bool clk_core_is_enabled(struct clk_core *core)
  {
  	/*
  	 * .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;

  	return core->ops->is_enabled(core->hw);
  }

  /***    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;

  }

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

  {

  	if (!core || index >= core->num_parents)
  		return NULL;

  
  	if (!core->parents[index])
  		core->parents[index] =
  				clk_core_lookup(core->parent_names[index]);
  
  	return core->parents[index];

  }

  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)
  {
  	unsigned long ret;

  	if (!core) {
  		ret = 0;
  		goto out;
  	}

  	ret = core->rate;

  	if (!core->num_parents)

  		goto out;

  	if (!core->parent)
  		ret = 0;

  out:
  	return ret;
  }

  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);
  }

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

  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;
  }

  static 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;

  }

  
  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;

  	*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);

  /*
   * 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.
   */

  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_unprepare(struct clk_core *core)
  {

  	lockdep_assert_held(&prepare_lock);

  	if (!core)
  		return;

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

  	if (WARN_ON(core->prepare_count == 1 && core->flags & CLK_IS_CRITICAL))
  		return;

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

  	WARN_ON(core->enable_count > 0);

  	trace_clk_unprepare(core);

  	if (core->ops->unprepare)
  		core->ops->unprepare(core->hw);
  
  	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_core_prepare(core->parent);
  		if (ret)
  			return ret;

  		trace_clk_prepare(core);

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

  		trace_clk_prepare_complete(core);

  		if (ret) {
  			clk_core_unprepare(core->parent);
  			return ret;
  		}
  	}

  	core->prepare_count++;

  
  	return 0;
  }

  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_ON(core->enable_count == 0))
  		return;

  	if (WARN_ON(core->enable_count == 1 && core->flags & CLK_IS_CRITICAL))
  		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_ON(core->prepare_count == 0))
  		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_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_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);
  	}
  }
  
  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);

  	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);

  	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_round_rate_nolock(struct clk_core *core,
  				      struct clk_rate_request *req)

  {

  	struct clk_core *parent;

  	long rate;

  
  	lockdep_assert_held(&prepare_lock);

  	if (!core)

  		return 0;

  	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;
  	}

  	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 if (core->flags & CLK_SET_RATE_PARENT) {
  		return clk_core_round_rate_nolock(parent, req);
  	} else {
  		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();

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

  	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);
  		}

  	}

  	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)

  {

  	if (core->ops->recalc_rate)
  		return core->ops->recalc_rate(core->hw, parent_rate);
  	return parent_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++)
  		if (clk_core_get_parent_by_index(core, i) == parent)

  			return i;

  	return -EINVAL;

  }

  /*
   * 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);

  	}
  }

  static int __clk_set_parent(struct clk_core *core, struct clk_core *parent,
  			    u8 p_index)
  {
  	unsigned long flags;
  	int ret = 0;
  	struct clk_core *old_parent;

  	old_parent = __clk_set_parent_before(core, parent);

  	trace_clk_set_parent(core, parent);

  	/* change clock input source */
  	if (parent && core->ops->set_parent)
  		ret = core->ops->set_parent(core->hw, p_index);

  	trace_clk_set_parent_complete(core, parent);

  	if (ret) {
  		flags = clk_enable_lock();
  		clk_reparent(core, old_parent);
  		clk_enable_unlock(flags);

  		__clk_set_parent_after(core, old_parent, parent);

  		return ret;

  	}

  	__clk_set_parent_after(core, parent, old_parent);

  	return 0;
  }
  
  /**

   * __clk_speculate_rates
   * @core: first clk in the subtree
   * @parent_rate: the "future" rate of clk's parent

   *

   * Walks the subtree of clks starting with clk, speculating rates as it
   * goes and firing off PRE_RATE_CHANGE notifications as necessary.
   *
   * Unlike clk_recalc_rates, clk_speculate_rates exists only for sending
   * pre-rate change notifications and returns early if no clks in the
   * subtree have subscribed to the notifications.  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.

   */

  static int __clk_speculate_rates(struct clk_core *core,
  				 unsigned long parent_rate)

  {

  	struct clk_core *child;
  	unsigned long new_rate;
  	int ret = NOTIFY_DONE;

  	lockdep_assert_held(&prepare_lock);

  	new_rate = clk_recalc(core, parent_rate);
  
  	/* abort rate change if a driver returns NOTIFY_BAD or NOTIFY_STOP */
  	if (core->notifier_count)
  		ret = __clk_notify(core, PRE_RATE_CHANGE, core->rate, new_rate);
  
  	if (ret & NOTIFY_STOP_MASK) {
  		pr_debug("%s: clk notifier callback for clock %s aborted with error %d
  ",
  				__func__, core->name, ret);
  		goto out;
  	}
  
  	hlist_for_each_entry(child, &core->children, child_node) {
  		ret = __clk_speculate_rates(child, new_rate);
  		if (ret & NOTIFY_STOP_MASK)
  			break;
  	}

  out:

  	return ret;
  }

  static void clk_calc_subtree(struct clk_core *core, unsigned long new_rate,
  			     struct clk_core *new_parent, u8 p_index)

  {

  	struct clk_core *child;

  	core->new_rate = new_rate;
  	core->new_parent = new_parent;
  	core->new_parent_index = p_index;
  	/* include clk in new parent's PRE_RATE_CHANGE notifications */
  	core->new_child = NULL;
  	if (new_parent && new_parent != core->parent)
  		new_parent->new_child = core;

  	hlist_for_each_entry(child, &core->children, child_node) {
  		child->new_rate = clk_recalc(child, new_rate);
  		clk_calc_subtree(child, child->new_rate, NULL, 0);
  	}
  }

  /*
   * calculate the new rates returning the topmost clock that has to be
   * changed.
   */
  static struct clk_core *clk_calc_new_rates(struct clk_core *core,
  					   unsigned long rate)
  {
  	struct clk_core *top = core;
  	struct clk_core *old_parent, *parent;

  	unsigned long best_parent_rate = 0;
  	unsigned long new_rate;
  	unsigned long min_rate;
  	unsigned long max_rate;
  	int p_index = 0;
  	long ret;
  
  	/* sanity */
  	if (IS_ERR_OR_NULL(core))
  		return NULL;
  
  	/* save parent rate, if it exists */
  	parent = old_parent = core->parent;

  	if (parent)

  		best_parent_rate = parent->rate;

  	clk_core_get_boundaries(core, &min_rate, &max_rate);
  
  	/* find the closest rate and parent clk/rate */

  	if (core->ops->determine_rate) {

  		struct clk_rate_request req;
  
  		req.rate = rate;
  		req.min_rate = min_rate;
  		req.max_rate = max_rate;
  		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;
  		}
  
  		ret = core->ops->determine_rate(core->hw, &req);

  		if (ret < 0)
  			return NULL;

  		best_parent_rate = req.best_parent_rate;
  		new_rate = req.rate;
  		parent = req.best_parent_hw ? req.best_parent_hw->core : NULL;

  	} else if (core->ops->round_rate) {
  		ret = core->ops->round_rate(core->hw, rate,

  					    &best_parent_rate);

  		if (ret < 0)
  			return NULL;

  		new_rate = ret;
  		if (new_rate < min_rate || new_rate > max_rate)
  			return NULL;
  	} else if (!parent || !(core->flags & CLK_SET_RATE_PARENT)) {
  		/* pass-through clock without adjustable parent */
  		core->new_rate = core->rate;
  		return NULL;
  	} else {
  		/* pass-through clock with adjustable parent */
  		top = clk_calc_new_rates(parent, rate);
  		new_rate = parent->new_rate;
  		goto out;
  	}

  	/* some clocks must be gated to change parent */
  	if (parent != old_parent &&
  	    (core->flags & CLK_SET_PARENT_GATE) && core->prepare_count) {
  		pr_debug("%s: %s not gated but wants to reparent
  ",
  			 __func__, core->name);
  		return NULL;
  	}

  	/* try finding the new parent index */
  	if (parent && core->num_parents > 1) {
  		p_index = clk_fetch_parent_index(core, parent);
  		if (p_index < 0) {
  			pr_debug("%s: clk %s can not be parent of clk %s
  ",
  				 __func__, parent->name, core->name);
  			return NULL;
  		}
  	}

  	if ((core->flags & CLK_SET_RATE_PARENT) && parent &&
  	    best_parent_rate != parent->rate)
  		top = clk_calc_new_rates(parent, best_parent_rate);

  out:
  	clk_calc_subtree(core, new_rate, parent, p_index);

  	return top;

  }

  /*
   * Notify about rate changes in a subtree. Always walk down the whole tree
   * so that in case of an error we can walk down the whole tree again and
   * abort the change.

   */

  static struct clk_core *clk_propagate_rate_change(struct clk_core *core,
  						  unsigned long event)

  {

  	struct clk_core *child, *tmp_clk, *fail_clk = NULL;

  	int ret = NOTIFY_DONE;

  	if (core->rate == core->new_rate)
  		return NULL;

  	if (core->notifier_count) {
  		ret = __clk_notify(core, event, core->rate, core->new_rate);
  		if (ret & NOTIFY_STOP_MASK)
  			fail_clk = core;

  	}

  	hlist_for_each_entry(child, &core->children, child_node) {
  		/* Skip children who will be reparented to another clock */
  		if (child->new_parent && child->new_parent != core)
  			continue;
  		tmp_clk = clk_propagate_rate_change(child, event);
  		if (tmp_clk)
  			fail_clk = tmp_clk;
  	}

  	/* handle the new child who might not be in core->children yet */
  	if (core->new_child) {
  		tmp_clk = clk_propagate_rate_change(core->new_child, event);
  		if (tmp_clk)
  			fail_clk = tmp_clk;
  	}

  	return fail_clk;

  }

  /*
   * walk down a subtree and set the new rates notifying the rate
   * change on the way
   */
  static void clk_change_rate(struct clk_core *core)

  {

  	struct clk_core *child;
  	struct hlist_node *tmp;
  	unsigned long old_rate;
  	unsigned long best_parent_rate = 0;
  	bool skip_set_rate = false;
  	struct clk_core *old_parent;

  	struct clk_core *parent = NULL;

  	old_rate = core->rate;

  	if (core->new_parent) {
  		parent = core->new_parent;

  		best_parent_rate = core->new_parent->rate;

  	} else if (core->parent) {
  		parent = core->parent;

  		best_parent_rate = core->parent->rate;

  	}

  	if (core->flags & CLK_SET_RATE_UNGATE) {
  		unsigned long flags;
  
  		clk_core_prepare(core);
  		flags = clk_enable_lock();
  		clk_core_enable(core);
  		clk_enable_unlock(flags);
  	}

  	if (core->new_parent && core->new_parent != core->parent) {
  		old_parent = __clk_set_parent_before(core, core->new_parent);
  		trace_clk_set_parent(core, core->new_parent);

  		if (core->ops->set_rate_and_parent) {
  			skip_set_rate = true;
  			core->ops->set_rate_and_parent(core->hw, core->new_rate,
  					best_parent_rate,
  					core->new_parent_index);
  		} else if (core->ops->set_parent) {
  			core->ops->set_parent(core->hw, core->new_parent_index);
  		}

  		trace_clk_set_parent_complete(core, core->new_parent);
  		__clk_set_parent_after(core, core->new_parent, old_parent);
  	}

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

  	trace_clk_set_rate(core, core->new_rate);

  	if (!skip_set_rate && core->ops->set_rate)
  		core->ops->set_rate(core->hw, core->new_rate, best_parent_rate);

  	trace_clk_set_rate_complete(core, core->new_rate);

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

  	if (core->flags & CLK_SET_RATE_UNGATE) {
  		unsigned long flags;
  
  		flags = clk_enable_lock();
  		clk_core_disable(core);
  		clk_enable_unlock(flags);
  		clk_core_unprepare(core);
  	}

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

  	if (core->notifier_count && old_rate != core->rate)
  		__clk_notify(core, POST_RATE_CHANGE, old_rate, core->rate);

  	if (core->flags & CLK_RECALC_NEW_RATES)
  		(void)clk_calc_new_rates(core, core->new_rate);

  	/*

  	 * Use safe iteration, as change_rate can actually swap parents
  	 * for certain clock types.

  	 */

  	hlist_for_each_entry_safe(child, tmp, &core->children, child_node) {
  		/* Skip children who will be reparented to another clock */
  		if (child->new_parent && child->new_parent != core)
  			continue;
  		clk_change_rate(child);
  	}

  	/* handle the new child who might not be in core->children yet */
  	if (core->new_child)
  		clk_change_rate(core->new_child);

  }

  static int clk_core_set_rate_nolock(struct clk_core *core,
  				    unsigned long req_rate)

  {

  	struct clk_core *top, *fail_clk;
  	unsigned long rate = req_rate;

  	if (!core)
  		return 0;

  	/* bail early if nothing to do */
  	if (rate == clk_core_get_rate_nolock(core))
  		return 0;

  	if ((core->flags & CLK_SET_RATE_GATE) && core->prepare_count)
  		return -EBUSY;

  	/* calculate new rates and get the topmost changed clock */
  	top = clk_calc_new_rates(core, rate);
  	if (!top)
  		return -EINVAL;
  
  	/* notify that we are about to change rates */
  	fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE);
  	if (fail_clk) {
  		pr_debug("%s: failed to set %s rate
  ", __func__,
  				fail_clk->name);
  		clk_propagate_rate_change(top, ABORT_RATE_CHANGE);
  		return -EBUSY;
  	}
  
  	/* change the rates */
  	clk_change_rate(top);
  
  	core->req_rate = req_rate;

  	return 0;

  }

  
  /**

   * clk_set_rate - specify a new rate for clk
   * @clk: the clk whose rate is being changed
   * @rate: the new rate for clk

   *

   * In the simplest case clk_set_rate will only adjust the rate of clk.
   *
   * Setting the CLK_SET_RATE_PARENT flag allows the rate change operation to
   * propagate up to clk's parent; whether or not this happens depends on the
   * outcome of clk's .round_rate implementation.  If *parent_rate is unchanged
   * after calling .round_rate then upstream parent propagation is ignored.  If
   * *parent_rate comes back with a new rate for clk's parent then we propagate
   * up to clk's parent and set its rate.  Upward propagation will continue
   * until either a clk does not support the CLK_SET_RATE_PARENT flag or
   * .round_rate stops requesting changes to clk's parent_rate.
   *
   * Rate changes are accomplished via tree traversal that also recalculates the
   * rates for the clocks and fires off POST_RATE_CHANGE notifiers.
   *
   * Returns 0 on success, -EERROR otherwise.

   */

  int clk_set_rate(struct clk *clk, unsigned long rate)

  {

  	int ret;

  	if (!clk)
  		return 0;

  	/* prevent racing with updates to the clock topology */
  	clk_prepare_lock();

  	ret = clk_core_set_rate_nolock(clk->core, rate);

  	clk_prepare_unlock();

  	return ret;

  }

  EXPORT_SYMBOL_GPL(clk_set_rate);

  /**
   * clk_set_rate_range - set a rate range for a clock source
   * @clk: clock source
   * @min: desired minimum clock rate in Hz, inclusive
   * @max: desired maximum clock rate in Hz, inclusive
   *
   * Returns success (0) or negative errno.
   */
  int clk_set_rate_range(struct clk *clk, unsigned long min, unsigned long max)

  {

  	int ret = 0;

  	if (!clk)
  		return 0;

  	if (min > max) {
  		pr_err("%s: clk %s dev %s con %s: invalid range [%lu, %lu]
  ",
  		       __func__, clk->core->name, clk->dev_id, clk->con_id,
  		       min, max);
  		return -EINVAL;