Linux 内核clk ops

/**
 * struct clk_ops -  Callback operations for hardware clocks; these are to
 * be provided by the clock implementation, and will be called by drivers
 * through the clk_* api.
 *
 * @prepare: Prepare the clock for enabling. This must not return until
 *  the clock is fully prepared, and it's safe to call clk_enable.
 *  This callback is intended to allow clock implementations to
 *  do any initialisation that may sleep. Called with
 *  prepare_lock held.
 *
 * @unprepare: Release the clock from its prepared state. This will typically
 *  undo any work done in the @prepare callback. Called with
 *  prepare_lock held.
 *
 * @is_prepared: Queries the hardware to determine if the clock is prepared.
 *  This function is allowed to sleep. Optional, if this op is not
 *  set then the prepare count will be used.
 *
 * @unprepare_unused: Unprepare the clock atomically.  Only called from
 *  clk_disable_unused for prepare clocks with special needs.
 *  Called with prepare mutex held. This function may sleep.
 *
 * @enable: Enable the clock atomically. This must not return until the
 *  clock is generating a valid clock signal, usable by consumer
 *  devices. Called with enable_lock held. This function must not
 *  sleep.
 *
 * @disable: Disable the clock atomically. Called with enable_lock held.
 *  This function must not sleep.
 *
 * @is_enabled: Queries the hardware to determine if the clock is enabled.
 *  This function must not sleep. Optional, if this op is not
 *  set then the enable count will be used.
 *
 * @disable_unused: Disable the clock atomically.  Only called from
 *  clk_disable_unused for gate clocks with special needs.
 *  Called with enable_lock held.  This function must not
 *  sleep.
 *
 * @recalc_rate Recalculate the rate of this clock, by querying hardware. The
 *  parent rate is an input parameter.  It is up to the caller to
 *  ensure that the prepare_mutex is held across this call.
 *  Returns the calculated rate.  Optional, but recommended - if
 *  this op is not set then clock rate will be initialized to 0.
 *
 * @round_rate: Given a target rate as input, returns the closest rate actually
 *  supported by the clock. The parent rate is an input/output
 *  parameter.
 *
 * @determine_rate: Given a target rate as input, returns the closest rate
 *  actually supported by the clock, and optionally the parent clock
 *  that should be used to provide the clock rate.
 *
 * @set_parent: Change the input source of this clock; for clocks with multiple
 *  possible parents specify a new parent by passing in the index
 *  as a u8 corresponding to the parent in either the .parent_names
 *  or .parents arrays.  This function in affect translates an
 *  array index into the value programmed into the hardware.
 *  Returns 0 on success, -EERROR otherwise.
 *
 * @get_parent: Queries the hardware to determine the parent of a clock.  The
 *  return value is a u8 which specifies the index corresponding to
 *  the parent clock.  This index can be applied to either the
 *  .parent_names or .parents arrays.  In short, this function
 *  translates the parent value read from hardware into an array
 *  index.  Currently only called when the clock is initialized by
 *  __clk_init.  This callback is mandatory for clocks with
 *  multiple parents.  It is optional (and unnecessary) for clocks
 *  with 0 or 1 parents.
 *
 * @set_rate: Change the rate of this clock. The requested rate is specified
 *  by the second argument, which should typically be the return
 *  of .round_rate call.  The third argument gives the parent rate
 *  which is likely helpful for most .set_rate implementation.
 *  Returns 0 on success, -EERROR otherwise.
 *
 * @set_rate_and_parent: Change the rate and the parent of this clock. The
 *  requested rate is specified by the second argument, which
 *  should typically be the return of .round_rate call.  The
 *  third argument gives the parent rate which is likely helpful
 *  for most .set_rate_and_parent implementation. The fourth
 *  argument gives the parent index. This callback is optional (and
 *  unnecessary) for clocks with 0 or 1 parents as well as
 *  for clocks that can tolerate switching the rate and the parent
 *  separately via calls to .set_parent and .set_rate.
 *  Returns 0 on success, -EERROR otherwise.
 *
 * @recalc_accuracy: Recalculate the accuracy of this clock. The clock accuracy
 *  is expressed in ppb (parts per billion). The parent accuracy is
 *  an input parameter.
 *  Returns the calculated accuracy.  Optional - if this op is not
 *  set then clock accuracy will be initialized to parent accuracy
 *  or 0 (perfect clock) if clock has no parent.
 *
 * @get_phase: Queries the hardware to get the current phase of a clock.
 *  Returned values are 0-359 degrees on success, negative
 *  error codes on failure.
 *
 * @set_phase: Shift the phase this clock signal in degrees specified
 *  by the second argument. Valid values for degrees are
 *  0-359. Return 0 on success, otherwise -EERROR.
 *
 * @init: Perform platform-specific initialization magic.
 *  This is not not used by any of the basic clock types.
 *  Please consider other ways of solving initialization problems
 *  before using this callback, as its use is discouraged.
 *
 * @debug_init: Set up type-specific debugfs entries for this clock.  This
 *  is called once, after the debugfs directory entry for this
 *  clock has been created.  The dentry pointer representing that
 *  directory is provided as an argument.  Called with
 *  prepare_lock held.  Returns 0 on success, -EERROR otherwise.
 *
 *
 * The clk_enable/clk_disable and clk_prepare/clk_unprepare pairs allow
 * implementations to split any work between atomic (enable) and sleepable
 * (prepare) contexts.  If enabling a clock requires code that might sleep,
 * this must be done in clk_prepare.  Clock enable code that will never be
 * called in a sleepable context may be implemented in clk_enable.
 *
 * Typically, drivers will call clk_prepare when a clock may be needed later
 * (eg. when a device is opened), and clk_enable when the clock is actually
 * required (eg. from an interrupt). Note that clk_prepare MUST have been
 * called before clk_enable.
 */
struct clk_ops {
 int  (*prepare)(struct clk_hw *hw);
 void  (*unprepare)(struct clk_hw *hw);
 int  (*is_prepared)(struct clk_hw *hw);
 void  (*unprepare_unused)(struct clk_hw *hw);
 int  (*enable)(struct clk_hw *hw);
 void  (*disable)(struct clk_hw *hw);
 int  (*is_enabled)(struct clk_hw *hw);
 void  (*disable_unused)(struct clk_hw *hw);
 unsigned long (*recalc_rate)(struct clk_hw *hw,
     unsigned long parent_rate);
 long  (*round_rate)(struct clk_hw *hw, unsigned long rate,
     unsigned long *parent_rate);
 int  (*determine_rate)(struct clk_hw *hw,
       struct clk_rate_request *req);
 int  (*set_parent)(struct clk_hw *hw, u8 index);
 u8  (*get_parent)(struct clk_hw *hw);
 int  (*set_rate)(struct clk_hw *hw, unsigned long rate,
        unsigned long parent_rate);
 int  (*set_rate_and_parent)(struct clk_hw *hw,
        unsigned long rate,
        unsigned long parent_rate, u8 index);
 unsigned long (*recalc_accuracy)(struct clk_hw *hw,
        unsigned long parent_accuracy);
 int  (*get_phase)(struct clk_hw *hw);
 int  (*set_phase)(struct clk_hw *hw, int degrees);
 void  (*init)(struct clk_hw *hw);
 int  (*debug_init)(struct clk_hw *hw, struct dentry *dentry);
};