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