Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[linux-2.6-microblaze.git] / include / linux / clk-provider.h
1 /*
2  *  linux/include/linux/clk-provider.h
3  *
4  *  Copyright (c) 2010-2011 Jeremy Kerr <jeremy.kerr@canonical.com>
5  *  Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11 #ifndef __LINUX_CLK_PROVIDER_H
12 #define __LINUX_CLK_PROVIDER_H
13
14 #include <linux/io.h>
15 #include <linux/of.h>
16
17 #ifdef CONFIG_COMMON_CLK
18
19 /*
20  * flags used across common struct clk.  these flags should only affect the
21  * top-level framework.  custom flags for dealing with hardware specifics
22  * belong in struct clk_foo
23  */
24 #define CLK_SET_RATE_GATE       BIT(0) /* must be gated across rate change */
25 #define CLK_SET_PARENT_GATE     BIT(1) /* must be gated across re-parent */
26 #define CLK_SET_RATE_PARENT     BIT(2) /* propagate rate change up one level */
27 #define CLK_IGNORE_UNUSED       BIT(3) /* do not gate even if unused */
28                                 /* unused */
29 #define CLK_IS_BASIC            BIT(5) /* Basic clk, can't do a to_clk_foo() */
30 #define CLK_GET_RATE_NOCACHE    BIT(6) /* do not use the cached clk rate */
31 #define CLK_SET_RATE_NO_REPARENT BIT(7) /* don't re-parent on rate change */
32 #define CLK_GET_ACCURACY_NOCACHE BIT(8) /* do not use the cached clk accuracy */
33 #define CLK_RECALC_NEW_RATES    BIT(9) /* recalc rates after notifications */
34 #define CLK_SET_RATE_UNGATE     BIT(10) /* clock needs to run to set rate */
35 #define CLK_IS_CRITICAL         BIT(11) /* do not gate, ever */
36 /* parents need enable during gate/ungate, set rate and re-parent */
37 #define CLK_OPS_PARENT_ENABLE   BIT(12)
38
39 struct clk;
40 struct clk_hw;
41 struct clk_core;
42 struct dentry;
43
44 /**
45  * struct clk_rate_request - Structure encoding the clk constraints that
46  * a clock user might require.
47  *
48  * @rate:               Requested clock rate. This field will be adjusted by
49  *                      clock drivers according to hardware capabilities.
50  * @min_rate:           Minimum rate imposed by clk users.
51  * @max_rate:           Maximum rate imposed by clk users.
52  * @best_parent_rate:   The best parent rate a parent can provide to fulfill the
53  *                      requested constraints.
54  * @best_parent_hw:     The most appropriate parent clock that fulfills the
55  *                      requested constraints.
56  *
57  */
58 struct clk_rate_request {
59         unsigned long rate;
60         unsigned long min_rate;
61         unsigned long max_rate;
62         unsigned long best_parent_rate;
63         struct clk_hw *best_parent_hw;
64 };
65
66 /**
67  * struct clk_ops -  Callback operations for hardware clocks; these are to
68  * be provided by the clock implementation, and will be called by drivers
69  * through the clk_* api.
70  *
71  * @prepare:    Prepare the clock for enabling. This must not return until
72  *              the clock is fully prepared, and it's safe to call clk_enable.
73  *              This callback is intended to allow clock implementations to
74  *              do any initialisation that may sleep. Called with
75  *              prepare_lock held.
76  *
77  * @unprepare:  Release the clock from its prepared state. This will typically
78  *              undo any work done in the @prepare callback. Called with
79  *              prepare_lock held.
80  *
81  * @is_prepared: Queries the hardware to determine if the clock is prepared.
82  *              This function is allowed to sleep. Optional, if this op is not
83  *              set then the prepare count will be used.
84  *
85  * @unprepare_unused: Unprepare the clock atomically.  Only called from
86  *              clk_disable_unused for prepare clocks with special needs.
87  *              Called with prepare mutex held. This function may sleep.
88  *
89  * @enable:     Enable the clock atomically. This must not return until the
90  *              clock is generating a valid clock signal, usable by consumer
91  *              devices. Called with enable_lock held. This function must not
92  *              sleep.
93  *
94  * @disable:    Disable the clock atomically. Called with enable_lock held.
95  *              This function must not sleep.
96  *
97  * @is_enabled: Queries the hardware to determine if the clock is enabled.
98  *              This function must not sleep. Optional, if this op is not
99  *              set then the enable count will be used.
100  *
101  * @disable_unused: Disable the clock atomically.  Only called from
102  *              clk_disable_unused for gate clocks with special needs.
103  *              Called with enable_lock held.  This function must not
104  *              sleep.
105  *
106  * @recalc_rate Recalculate the rate of this clock, by querying hardware. The
107  *              parent rate is an input parameter.  It is up to the caller to
108  *              ensure that the prepare_mutex is held across this call.
109  *              Returns the calculated rate.  Optional, but recommended - if
110  *              this op is not set then clock rate will be initialized to 0.
111  *
112  * @round_rate: Given a target rate as input, returns the closest rate actually
113  *              supported by the clock. The parent rate is an input/output
114  *              parameter.
115  *
116  * @determine_rate: Given a target rate as input, returns the closest rate
117  *              actually supported by the clock, and optionally the parent clock
118  *              that should be used to provide the clock rate.
119  *
120  * @set_parent: Change the input source of this clock; for clocks with multiple
121  *              possible parents specify a new parent by passing in the index
122  *              as a u8 corresponding to the parent in either the .parent_names
123  *              or .parents arrays.  This function in affect translates an
124  *              array index into the value programmed into the hardware.
125  *              Returns 0 on success, -EERROR otherwise.
126  *
127  * @get_parent: Queries the hardware to determine the parent of a clock.  The
128  *              return value is a u8 which specifies the index corresponding to
129  *              the parent clock.  This index can be applied to either the
130  *              .parent_names or .parents arrays.  In short, this function
131  *              translates the parent value read from hardware into an array
132  *              index.  Currently only called when the clock is initialized by
133  *              __clk_init.  This callback is mandatory for clocks with
134  *              multiple parents.  It is optional (and unnecessary) for clocks
135  *              with 0 or 1 parents.
136  *
137  * @set_rate:   Change the rate of this clock. The requested rate is specified
138  *              by the second argument, which should typically be the return
139  *              of .round_rate call.  The third argument gives the parent rate
140  *              which is likely helpful for most .set_rate implementation.
141  *              Returns 0 on success, -EERROR otherwise.
142  *
143  * @set_rate_and_parent: Change the rate and the parent of this clock. The
144  *              requested rate is specified by the second argument, which
145  *              should typically be the return of .round_rate call.  The
146  *              third argument gives the parent rate which is likely helpful
147  *              for most .set_rate_and_parent implementation. The fourth
148  *              argument gives the parent index. This callback is optional (and
149  *              unnecessary) for clocks with 0 or 1 parents as well as
150  *              for clocks that can tolerate switching the rate and the parent
151  *              separately via calls to .set_parent and .set_rate.
152  *              Returns 0 on success, -EERROR otherwise.
153  *
154  * @recalc_accuracy: Recalculate the accuracy of this clock. The clock accuracy
155  *              is expressed in ppb (parts per billion). The parent accuracy is
156  *              an input parameter.
157  *              Returns the calculated accuracy.  Optional - if this op is not
158  *              set then clock accuracy will be initialized to parent accuracy
159  *              or 0 (perfect clock) if clock has no parent.
160  *
161  * @get_phase:  Queries the hardware to get the current phase of a clock.
162  *              Returned values are 0-359 degrees on success, negative
163  *              error codes on failure.
164  *
165  * @set_phase:  Shift the phase this clock signal in degrees specified
166  *              by the second argument. Valid values for degrees are
167  *              0-359. Return 0 on success, otherwise -EERROR.
168  *
169  * @init:       Perform platform-specific initialization magic.
170  *              This is not not used by any of the basic clock types.
171  *              Please consider other ways of solving initialization problems
172  *              before using this callback, as its use is discouraged.
173  *
174  * @debug_init: Set up type-specific debugfs entries for this clock.  This
175  *              is called once, after the debugfs directory entry for this
176  *              clock has been created.  The dentry pointer representing that
177  *              directory is provided as an argument.  Called with
178  *              prepare_lock held.  Returns 0 on success, -EERROR otherwise.
179  *
180  *
181  * The clk_enable/clk_disable and clk_prepare/clk_unprepare pairs allow
182  * implementations to split any work between atomic (enable) and sleepable
183  * (prepare) contexts.  If enabling a clock requires code that might sleep,
184  * this must be done in clk_prepare.  Clock enable code that will never be
185  * called in a sleepable context may be implemented in clk_enable.
186  *
187  * Typically, drivers will call clk_prepare when a clock may be needed later
188  * (eg. when a device is opened), and clk_enable when the clock is actually
189  * required (eg. from an interrupt). Note that clk_prepare MUST have been
190  * called before clk_enable.
191  */
192 struct clk_ops {
193         int             (*prepare)(struct clk_hw *hw);
194         void            (*unprepare)(struct clk_hw *hw);
195         int             (*is_prepared)(struct clk_hw *hw);
196         void            (*unprepare_unused)(struct clk_hw *hw);
197         int             (*enable)(struct clk_hw *hw);
198         void            (*disable)(struct clk_hw *hw);
199         int             (*is_enabled)(struct clk_hw *hw);
200         void            (*disable_unused)(struct clk_hw *hw);
201         unsigned long   (*recalc_rate)(struct clk_hw *hw,
202                                         unsigned long parent_rate);
203         long            (*round_rate)(struct clk_hw *hw, unsigned long rate,
204                                         unsigned long *parent_rate);
205         int             (*determine_rate)(struct clk_hw *hw,
206                                           struct clk_rate_request *req);
207         int             (*set_parent)(struct clk_hw *hw, u8 index);
208         u8              (*get_parent)(struct clk_hw *hw);
209         int             (*set_rate)(struct clk_hw *hw, unsigned long rate,
210                                     unsigned long parent_rate);
211         int             (*set_rate_and_parent)(struct clk_hw *hw,
212                                     unsigned long rate,
213                                     unsigned long parent_rate, u8 index);
214         unsigned long   (*recalc_accuracy)(struct clk_hw *hw,
215                                            unsigned long parent_accuracy);
216         int             (*get_phase)(struct clk_hw *hw);
217         int             (*set_phase)(struct clk_hw *hw, int degrees);
218         void            (*init)(struct clk_hw *hw);
219         int             (*debug_init)(struct clk_hw *hw, struct dentry *dentry);
220 };
221
222 /**
223  * struct clk_init_data - holds init data that's common to all clocks and is
224  * shared between the clock provider and the common clock framework.
225  *
226  * @name: clock name
227  * @ops: operations this clock supports
228  * @parent_names: array of string names for all possible parents
229  * @num_parents: number of possible parents
230  * @flags: framework-level hints and quirks
231  */
232 struct clk_init_data {
233         const char              *name;
234         const struct clk_ops    *ops;
235         const char              * const *parent_names;
236         u8                      num_parents;
237         unsigned long           flags;
238 };
239
240 /**
241  * struct clk_hw - handle for traversing from a struct clk to its corresponding
242  * hardware-specific structure.  struct clk_hw should be declared within struct
243  * clk_foo and then referenced by the struct clk instance that uses struct
244  * clk_foo's clk_ops
245  *
246  * @core: pointer to the struct clk_core instance that points back to this
247  * struct clk_hw instance
248  *
249  * @clk: pointer to the per-user struct clk instance that can be used to call
250  * into the clk API
251  *
252  * @init: pointer to struct clk_init_data that contains the init data shared
253  * with the common clock framework.
254  */
255 struct clk_hw {
256         struct clk_core *core;
257         struct clk *clk;
258         const struct clk_init_data *init;
259 };
260
261 /*
262  * DOC: Basic clock implementations common to many platforms
263  *
264  * Each basic clock hardware type is comprised of a structure describing the
265  * clock hardware, implementations of the relevant callbacks in struct clk_ops,
266  * unique flags for that hardware type, a registration function and an
267  * alternative macro for static initialization
268  */
269
270 /**
271  * struct clk_fixed_rate - fixed-rate clock
272  * @hw:         handle between common and hardware-specific interfaces
273  * @fixed_rate: constant frequency of clock
274  */
275 struct clk_fixed_rate {
276         struct          clk_hw hw;
277         unsigned long   fixed_rate;
278         unsigned long   fixed_accuracy;
279         u8              flags;
280 };
281
282 #define to_clk_fixed_rate(_hw) container_of(_hw, struct clk_fixed_rate, hw)
283
284 extern const struct clk_ops clk_fixed_rate_ops;
285 struct clk *clk_register_fixed_rate(struct device *dev, const char *name,
286                 const char *parent_name, unsigned long flags,
287                 unsigned long fixed_rate);
288 struct clk_hw *clk_hw_register_fixed_rate(struct device *dev, const char *name,
289                 const char *parent_name, unsigned long flags,
290                 unsigned long fixed_rate);
291 struct clk *clk_register_fixed_rate_with_accuracy(struct device *dev,
292                 const char *name, const char *parent_name, unsigned long flags,
293                 unsigned long fixed_rate, unsigned long fixed_accuracy);
294 void clk_unregister_fixed_rate(struct clk *clk);
295 struct clk_hw *clk_hw_register_fixed_rate_with_accuracy(struct device *dev,
296                 const char *name, const char *parent_name, unsigned long flags,
297                 unsigned long fixed_rate, unsigned long fixed_accuracy);
298 void clk_hw_unregister_fixed_rate(struct clk_hw *hw);
299
300 void of_fixed_clk_setup(struct device_node *np);
301
302 /**
303  * struct clk_gate - gating clock
304  *
305  * @hw:         handle between common and hardware-specific interfaces
306  * @reg:        register controlling gate
307  * @bit_idx:    single bit controlling gate
308  * @flags:      hardware-specific flags
309  * @lock:       register lock
310  *
311  * Clock which can gate its output.  Implements .enable & .disable
312  *
313  * Flags:
314  * CLK_GATE_SET_TO_DISABLE - by default this clock sets the bit at bit_idx to
315  *      enable the clock.  Setting this flag does the opposite: setting the bit
316  *      disable the clock and clearing it enables the clock
317  * CLK_GATE_HIWORD_MASK - The gate settings are only in lower 16-bit
318  *      of this register, and mask of gate bits are in higher 16-bit of this
319  *      register.  While setting the gate bits, higher 16-bit should also be
320  *      updated to indicate changing gate bits.
321  */
322 struct clk_gate {
323         struct clk_hw hw;
324         void __iomem    *reg;
325         u8              bit_idx;
326         u8              flags;
327         spinlock_t      *lock;
328 };
329
330 #define to_clk_gate(_hw) container_of(_hw, struct clk_gate, hw)
331
332 #define CLK_GATE_SET_TO_DISABLE         BIT(0)
333 #define CLK_GATE_HIWORD_MASK            BIT(1)
334
335 extern const struct clk_ops clk_gate_ops;
336 struct clk *clk_register_gate(struct device *dev, const char *name,
337                 const char *parent_name, unsigned long flags,
338                 void __iomem *reg, u8 bit_idx,
339                 u8 clk_gate_flags, spinlock_t *lock);
340 struct clk_hw *clk_hw_register_gate(struct device *dev, const char *name,
341                 const char *parent_name, unsigned long flags,
342                 void __iomem *reg, u8 bit_idx,
343                 u8 clk_gate_flags, spinlock_t *lock);
344 void clk_unregister_gate(struct clk *clk);
345 void clk_hw_unregister_gate(struct clk_hw *hw);
346 int clk_gate_is_enabled(struct clk_hw *hw);
347
348 struct clk_div_table {
349         unsigned int    val;
350         unsigned int    div;
351 };
352
353 /**
354  * struct clk_divider - adjustable divider clock
355  *
356  * @hw:         handle between common and hardware-specific interfaces
357  * @reg:        register containing the divider
358  * @shift:      shift to the divider bit field
359  * @width:      width of the divider bit field
360  * @table:      array of value/divider pairs, last entry should have div = 0
361  * @lock:       register lock
362  *
363  * Clock with an adjustable divider affecting its output frequency.  Implements
364  * .recalc_rate, .set_rate and .round_rate
365  *
366  * Flags:
367  * CLK_DIVIDER_ONE_BASED - by default the divisor is the value read from the
368  *      register plus one.  If CLK_DIVIDER_ONE_BASED is set then the divider is
369  *      the raw value read from the register, with the value of zero considered
370  *      invalid, unless CLK_DIVIDER_ALLOW_ZERO is set.
371  * CLK_DIVIDER_POWER_OF_TWO - clock divisor is 2 raised to the value read from
372  *      the hardware register
373  * CLK_DIVIDER_ALLOW_ZERO - Allow zero divisors.  For dividers which have
374  *      CLK_DIVIDER_ONE_BASED set, it is possible to end up with a zero divisor.
375  *      Some hardware implementations gracefully handle this case and allow a
376  *      zero divisor by not modifying their input clock
377  *      (divide by one / bypass).
378  * CLK_DIVIDER_HIWORD_MASK - The divider settings are only in lower 16-bit
379  *      of this register, and mask of divider bits are in higher 16-bit of this
380  *      register.  While setting the divider bits, higher 16-bit should also be
381  *      updated to indicate changing divider bits.
382  * CLK_DIVIDER_ROUND_CLOSEST - Makes the best calculated divider to be rounded
383  *      to the closest integer instead of the up one.
384  * CLK_DIVIDER_READ_ONLY - The divider settings are preconfigured and should
385  *      not be changed by the clock framework.
386  * CLK_DIVIDER_MAX_AT_ZERO - For dividers which are like CLK_DIVIDER_ONE_BASED
387  *      except when the value read from the register is zero, the divisor is
388  *      2^width of the field.
389  */
390 struct clk_divider {
391         struct clk_hw   hw;
392         void __iomem    *reg;
393         u8              shift;
394         u8              width;
395         u8              flags;
396         const struct clk_div_table      *table;
397         spinlock_t      *lock;
398 };
399
400 #define to_clk_divider(_hw) container_of(_hw, struct clk_divider, hw)
401
402 #define CLK_DIVIDER_ONE_BASED           BIT(0)
403 #define CLK_DIVIDER_POWER_OF_TWO        BIT(1)
404 #define CLK_DIVIDER_ALLOW_ZERO          BIT(2)
405 #define CLK_DIVIDER_HIWORD_MASK         BIT(3)
406 #define CLK_DIVIDER_ROUND_CLOSEST       BIT(4)
407 #define CLK_DIVIDER_READ_ONLY           BIT(5)
408 #define CLK_DIVIDER_MAX_AT_ZERO         BIT(6)
409
410 extern const struct clk_ops clk_divider_ops;
411 extern const struct clk_ops clk_divider_ro_ops;
412
413 unsigned long divider_recalc_rate(struct clk_hw *hw, unsigned long parent_rate,
414                 unsigned int val, const struct clk_div_table *table,
415                 unsigned long flags);
416 long divider_round_rate_parent(struct clk_hw *hw, struct clk_hw *parent,
417                                unsigned long rate, unsigned long *prate,
418                                const struct clk_div_table *table,
419                                u8 width, unsigned long flags);
420 int divider_get_val(unsigned long rate, unsigned long parent_rate,
421                 const struct clk_div_table *table, u8 width,
422                 unsigned long flags);
423
424 struct clk *clk_register_divider(struct device *dev, const char *name,
425                 const char *parent_name, unsigned long flags,
426                 void __iomem *reg, u8 shift, u8 width,
427                 u8 clk_divider_flags, spinlock_t *lock);
428 struct clk_hw *clk_hw_register_divider(struct device *dev, const char *name,
429                 const char *parent_name, unsigned long flags,
430                 void __iomem *reg, u8 shift, u8 width,
431                 u8 clk_divider_flags, spinlock_t *lock);
432 struct clk *clk_register_divider_table(struct device *dev, const char *name,
433                 const char *parent_name, unsigned long flags,
434                 void __iomem *reg, u8 shift, u8 width,
435                 u8 clk_divider_flags, const struct clk_div_table *table,
436                 spinlock_t *lock);
437 struct clk_hw *clk_hw_register_divider_table(struct device *dev,
438                 const char *name, const char *parent_name, unsigned long flags,
439                 void __iomem *reg, u8 shift, u8 width,
440                 u8 clk_divider_flags, const struct clk_div_table *table,
441                 spinlock_t *lock);
442 void clk_unregister_divider(struct clk *clk);
443 void clk_hw_unregister_divider(struct clk_hw *hw);
444
445 /**
446  * struct clk_mux - multiplexer clock
447  *
448  * @hw:         handle between common and hardware-specific interfaces
449  * @reg:        register controlling multiplexer
450  * @shift:      shift to multiplexer bit field
451  * @width:      width of mutliplexer bit field
452  * @flags:      hardware-specific flags
453  * @lock:       register lock
454  *
455  * Clock with multiple selectable parents.  Implements .get_parent, .set_parent
456  * and .recalc_rate
457  *
458  * Flags:
459  * CLK_MUX_INDEX_ONE - register index starts at 1, not 0
460  * CLK_MUX_INDEX_BIT - register index is a single bit (power of two)
461  * CLK_MUX_HIWORD_MASK - The mux settings are only in lower 16-bit of this
462  *      register, and mask of mux bits are in higher 16-bit of this register.
463  *      While setting the mux bits, higher 16-bit should also be updated to
464  *      indicate changing mux bits.
465  * CLK_MUX_ROUND_CLOSEST - Use the parent rate that is closest to the desired
466  *      frequency.
467  */
468 struct clk_mux {
469         struct clk_hw   hw;
470         void __iomem    *reg;
471         u32             *table;
472         u32             mask;
473         u8              shift;
474         u8              flags;
475         spinlock_t      *lock;
476 };
477
478 #define to_clk_mux(_hw) container_of(_hw, struct clk_mux, hw)
479
480 #define CLK_MUX_INDEX_ONE               BIT(0)
481 #define CLK_MUX_INDEX_BIT               BIT(1)
482 #define CLK_MUX_HIWORD_MASK             BIT(2)
483 #define CLK_MUX_READ_ONLY               BIT(3) /* mux can't be changed */
484 #define CLK_MUX_ROUND_CLOSEST           BIT(4)
485
486 extern const struct clk_ops clk_mux_ops;
487 extern const struct clk_ops clk_mux_ro_ops;
488
489 struct clk *clk_register_mux(struct device *dev, const char *name,
490                 const char * const *parent_names, u8 num_parents,
491                 unsigned long flags,
492                 void __iomem *reg, u8 shift, u8 width,
493                 u8 clk_mux_flags, spinlock_t *lock);
494 struct clk_hw *clk_hw_register_mux(struct device *dev, const char *name,
495                 const char * const *parent_names, u8 num_parents,
496                 unsigned long flags,
497                 void __iomem *reg, u8 shift, u8 width,
498                 u8 clk_mux_flags, spinlock_t *lock);
499
500 struct clk *clk_register_mux_table(struct device *dev, const char *name,
501                 const char * const *parent_names, u8 num_parents,
502                 unsigned long flags,
503                 void __iomem *reg, u8 shift, u32 mask,
504                 u8 clk_mux_flags, u32 *table, spinlock_t *lock);
505 struct clk_hw *clk_hw_register_mux_table(struct device *dev, const char *name,
506                 const char * const *parent_names, u8 num_parents,
507                 unsigned long flags,
508                 void __iomem *reg, u8 shift, u32 mask,
509                 u8 clk_mux_flags, u32 *table, spinlock_t *lock);
510
511 void clk_unregister_mux(struct clk *clk);
512 void clk_hw_unregister_mux(struct clk_hw *hw);
513
514 void of_fixed_factor_clk_setup(struct device_node *node);
515
516 /**
517  * struct clk_fixed_factor - fixed multiplier and divider clock
518  *
519  * @hw:         handle between common and hardware-specific interfaces
520  * @mult:       multiplier
521  * @div:        divider
522  *
523  * Clock with a fixed multiplier and divider. The output frequency is the
524  * parent clock rate divided by div and multiplied by mult.
525  * Implements .recalc_rate, .set_rate and .round_rate
526  */
527
528 struct clk_fixed_factor {
529         struct clk_hw   hw;
530         unsigned int    mult;
531         unsigned int    div;
532 };
533
534 #define to_clk_fixed_factor(_hw) container_of(_hw, struct clk_fixed_factor, hw)
535
536 extern const struct clk_ops clk_fixed_factor_ops;
537 struct clk *clk_register_fixed_factor(struct device *dev, const char *name,
538                 const char *parent_name, unsigned long flags,
539                 unsigned int mult, unsigned int div);
540 void clk_unregister_fixed_factor(struct clk *clk);
541 struct clk_hw *clk_hw_register_fixed_factor(struct device *dev,
542                 const char *name, const char *parent_name, unsigned long flags,
543                 unsigned int mult, unsigned int div);
544 void clk_hw_unregister_fixed_factor(struct clk_hw *hw);
545
546 /**
547  * struct clk_fractional_divider - adjustable fractional divider clock
548  *
549  * @hw:         handle between common and hardware-specific interfaces
550  * @reg:        register containing the divider
551  * @mshift:     shift to the numerator bit field
552  * @mwidth:     width of the numerator bit field
553  * @nshift:     shift to the denominator bit field
554  * @nwidth:     width of the denominator bit field
555  * @lock:       register lock
556  *
557  * Clock with adjustable fractional divider affecting its output frequency.
558  */
559 struct clk_fractional_divider {
560         struct clk_hw   hw;
561         void __iomem    *reg;
562         u8              mshift;
563         u8              mwidth;
564         u32             mmask;
565         u8              nshift;
566         u8              nwidth;
567         u32             nmask;
568         u8              flags;
569         void            (*approximation)(struct clk_hw *hw,
570                                 unsigned long rate, unsigned long *parent_rate,
571                                 unsigned long *m, unsigned long *n);
572         spinlock_t      *lock;
573 };
574
575 #define to_clk_fd(_hw) container_of(_hw, struct clk_fractional_divider, hw)
576
577 extern const struct clk_ops clk_fractional_divider_ops;
578 struct clk *clk_register_fractional_divider(struct device *dev,
579                 const char *name, const char *parent_name, unsigned long flags,
580                 void __iomem *reg, u8 mshift, u8 mwidth, u8 nshift, u8 nwidth,
581                 u8 clk_divider_flags, spinlock_t *lock);
582 struct clk_hw *clk_hw_register_fractional_divider(struct device *dev,
583                 const char *name, const char *parent_name, unsigned long flags,
584                 void __iomem *reg, u8 mshift, u8 mwidth, u8 nshift, u8 nwidth,
585                 u8 clk_divider_flags, spinlock_t *lock);
586 void clk_hw_unregister_fractional_divider(struct clk_hw *hw);
587
588 /**
589  * struct clk_multiplier - adjustable multiplier clock
590  *
591  * @hw:         handle between common and hardware-specific interfaces
592  * @reg:        register containing the multiplier
593  * @shift:      shift to the multiplier bit field
594  * @width:      width of the multiplier bit field
595  * @lock:       register lock
596  *
597  * Clock with an adjustable multiplier affecting its output frequency.
598  * Implements .recalc_rate, .set_rate and .round_rate
599  *
600  * Flags:
601  * CLK_MULTIPLIER_ZERO_BYPASS - By default, the multiplier is the value read
602  *      from the register, with 0 being a valid value effectively
603  *      zeroing the output clock rate. If CLK_MULTIPLIER_ZERO_BYPASS is
604  *      set, then a null multiplier will be considered as a bypass,
605  *      leaving the parent rate unmodified.
606  * CLK_MULTIPLIER_ROUND_CLOSEST - Makes the best calculated divider to be
607  *      rounded to the closest integer instead of the down one.
608  */
609 struct clk_multiplier {
610         struct clk_hw   hw;
611         void __iomem    *reg;
612         u8              shift;
613         u8              width;
614         u8              flags;
615         spinlock_t      *lock;
616 };
617
618 #define to_clk_multiplier(_hw) container_of(_hw, struct clk_multiplier, hw)
619
620 #define CLK_MULTIPLIER_ZERO_BYPASS              BIT(0)
621 #define CLK_MULTIPLIER_ROUND_CLOSEST    BIT(1)
622
623 extern const struct clk_ops clk_multiplier_ops;
624
625 /***
626  * struct clk_composite - aggregate clock of mux, divider and gate clocks
627  *
628  * @hw:         handle between common and hardware-specific interfaces
629  * @mux_hw:     handle between composite and hardware-specific mux clock
630  * @rate_hw:    handle between composite and hardware-specific rate clock
631  * @gate_hw:    handle between composite and hardware-specific gate clock
632  * @mux_ops:    clock ops for mux
633  * @rate_ops:   clock ops for rate
634  * @gate_ops:   clock ops for gate
635  */
636 struct clk_composite {
637         struct clk_hw   hw;
638         struct clk_ops  ops;
639
640         struct clk_hw   *mux_hw;
641         struct clk_hw   *rate_hw;
642         struct clk_hw   *gate_hw;
643
644         const struct clk_ops    *mux_ops;
645         const struct clk_ops    *rate_ops;
646         const struct clk_ops    *gate_ops;
647 };
648
649 #define to_clk_composite(_hw) container_of(_hw, struct clk_composite, hw)
650
651 struct clk *clk_register_composite(struct device *dev, const char *name,
652                 const char * const *parent_names, int num_parents,
653                 struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
654                 struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
655                 struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
656                 unsigned long flags);
657 void clk_unregister_composite(struct clk *clk);
658 struct clk_hw *clk_hw_register_composite(struct device *dev, const char *name,
659                 const char * const *parent_names, int num_parents,
660                 struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
661                 struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
662                 struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
663                 unsigned long flags);
664 void clk_hw_unregister_composite(struct clk_hw *hw);
665
666 /***
667  * struct clk_gpio_gate - gpio gated clock
668  *
669  * @hw:         handle between common and hardware-specific interfaces
670  * @gpiod:      gpio descriptor
671  *
672  * Clock with a gpio control for enabling and disabling the parent clock.
673  * Implements .enable, .disable and .is_enabled
674  */
675
676 struct clk_gpio {
677         struct clk_hw   hw;
678         struct gpio_desc *gpiod;
679 };
680
681 #define to_clk_gpio(_hw) container_of(_hw, struct clk_gpio, hw)
682
683 extern const struct clk_ops clk_gpio_gate_ops;
684 struct clk *clk_register_gpio_gate(struct device *dev, const char *name,
685                 const char *parent_name, unsigned gpio, bool active_low,
686                 unsigned long flags);
687 struct clk_hw *clk_hw_register_gpio_gate(struct device *dev, const char *name,
688                 const char *parent_name, unsigned gpio, bool active_low,
689                 unsigned long flags);
690 void clk_hw_unregister_gpio_gate(struct clk_hw *hw);
691
692 /**
693  * struct clk_gpio_mux - gpio controlled clock multiplexer
694  *
695  * @hw:         see struct clk_gpio
696  * @gpiod:      gpio descriptor to select the parent of this clock multiplexer
697  *
698  * Clock with a gpio control for selecting the parent clock.
699  * Implements .get_parent, .set_parent and .determine_rate
700  */
701
702 extern const struct clk_ops clk_gpio_mux_ops;
703 struct clk *clk_register_gpio_mux(struct device *dev, const char *name,
704                 const char * const *parent_names, u8 num_parents, unsigned gpio,
705                 bool active_low, unsigned long flags);
706 struct clk_hw *clk_hw_register_gpio_mux(struct device *dev, const char *name,
707                 const char * const *parent_names, u8 num_parents, unsigned gpio,
708                 bool active_low, unsigned long flags);
709 void clk_hw_unregister_gpio_mux(struct clk_hw *hw);
710
711 /**
712  * clk_register - allocate a new clock, register it and return an opaque cookie
713  * @dev: device that is registering this clock
714  * @hw: link to hardware-specific clock data
715  *
716  * clk_register is the primary interface for populating the clock tree with new
717  * clock nodes.  It returns a pointer to the newly allocated struct clk which
718  * cannot be dereferenced by driver code but may be used in conjuction with the
719  * rest of the clock API.  In the event of an error clk_register will return an
720  * error code; drivers must test for an error code after calling clk_register.
721  */
722 struct clk *clk_register(struct device *dev, struct clk_hw *hw);
723 struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw);
724
725 int __must_check clk_hw_register(struct device *dev, struct clk_hw *hw);
726 int __must_check devm_clk_hw_register(struct device *dev, struct clk_hw *hw);
727
728 void clk_unregister(struct clk *clk);
729 void devm_clk_unregister(struct device *dev, struct clk *clk);
730
731 void clk_hw_unregister(struct clk_hw *hw);
732 void devm_clk_hw_unregister(struct device *dev, struct clk_hw *hw);
733
734 /* helper functions */
735 const char *__clk_get_name(const struct clk *clk);
736 const char *clk_hw_get_name(const struct clk_hw *hw);
737 struct clk_hw *__clk_get_hw(struct clk *clk);
738 unsigned int clk_hw_get_num_parents(const struct clk_hw *hw);
739 struct clk_hw *clk_hw_get_parent(const struct clk_hw *hw);
740 struct clk_hw *clk_hw_get_parent_by_index(const struct clk_hw *hw,
741                                           unsigned int index);
742 unsigned int __clk_get_enable_count(struct clk *clk);
743 unsigned long clk_hw_get_rate(const struct clk_hw *hw);
744 unsigned long __clk_get_flags(struct clk *clk);
745 unsigned long clk_hw_get_flags(const struct clk_hw *hw);
746 bool clk_hw_is_prepared(const struct clk_hw *hw);
747 bool clk_hw_is_enabled(const struct clk_hw *hw);
748 bool __clk_is_enabled(struct clk *clk);
749 struct clk *__clk_lookup(const char *name);
750 int __clk_mux_determine_rate(struct clk_hw *hw,
751                              struct clk_rate_request *req);
752 int __clk_determine_rate(struct clk_hw *core, struct clk_rate_request *req);
753 int __clk_mux_determine_rate_closest(struct clk_hw *hw,
754                                      struct clk_rate_request *req);
755 void clk_hw_reparent(struct clk_hw *hw, struct clk_hw *new_parent);
756 void clk_hw_set_rate_range(struct clk_hw *hw, unsigned long min_rate,
757                            unsigned long max_rate);
758
759 static inline void __clk_hw_set_clk(struct clk_hw *dst, struct clk_hw *src)
760 {
761         dst->clk = src->clk;
762         dst->core = src->core;
763 }
764
765 static inline long divider_round_rate(struct clk_hw *hw, unsigned long rate,
766                                       unsigned long *prate,
767                                       const struct clk_div_table *table,
768                                       u8 width, unsigned long flags)
769 {
770         return divider_round_rate_parent(hw, clk_hw_get_parent(hw),
771                                          rate, prate, table, width, flags);
772 }
773
774 /*
775  * FIXME clock api without lock protection
776  */
777 unsigned long clk_hw_round_rate(struct clk_hw *hw, unsigned long rate);
778
779 struct of_device_id;
780
781 typedef void (*of_clk_init_cb_t)(struct device_node *);
782
783 struct clk_onecell_data {
784         struct clk **clks;
785         unsigned int clk_num;
786 };
787
788 struct clk_hw_onecell_data {
789         unsigned int num;
790         struct clk_hw *hws[];
791 };
792
793 extern struct of_device_id __clk_of_table;
794
795 #define CLK_OF_DECLARE(name, compat, fn) OF_DECLARE_1(clk, name, compat, fn)
796
797 /*
798  * Use this macro when you have a driver that requires two initialization
799  * routines, one at of_clk_init(), and one at platform device probe
800  */
801 #define CLK_OF_DECLARE_DRIVER(name, compat, fn) \
802         static void __init name##_of_clk_init_driver(struct device_node *np) \
803         {                                                               \
804                 of_node_clear_flag(np, OF_POPULATED);                   \
805                 fn(np);                                                 \
806         }                                                               \
807         OF_DECLARE_1(clk, name, compat, name##_of_clk_init_driver)
808
809 #ifdef CONFIG_OF
810 int of_clk_add_provider(struct device_node *np,
811                         struct clk *(*clk_src_get)(struct of_phandle_args *args,
812                                                    void *data),
813                         void *data);
814 int of_clk_add_hw_provider(struct device_node *np,
815                            struct clk_hw *(*get)(struct of_phandle_args *clkspec,
816                                                  void *data),
817                            void *data);
818 void of_clk_del_provider(struct device_node *np);
819 struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
820                                   void *data);
821 struct clk_hw *of_clk_hw_simple_get(struct of_phandle_args *clkspec,
822                                     void *data);
823 struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data);
824 struct clk_hw *of_clk_hw_onecell_get(struct of_phandle_args *clkspec,
825                                      void *data);
826 unsigned int of_clk_get_parent_count(struct device_node *np);
827 int of_clk_parent_fill(struct device_node *np, const char **parents,
828                        unsigned int size);
829 const char *of_clk_get_parent_name(struct device_node *np, int index);
830 int of_clk_detect_critical(struct device_node *np, int index,
831                             unsigned long *flags);
832 void of_clk_init(const struct of_device_id *matches);
833
834 #else /* !CONFIG_OF */
835
836 static inline int of_clk_add_provider(struct device_node *np,
837                         struct clk *(*clk_src_get)(struct of_phandle_args *args,
838                                                    void *data),
839                         void *data)
840 {
841         return 0;
842 }
843 static inline int of_clk_add_hw_provider(struct device_node *np,
844                         struct clk_hw *(*get)(struct of_phandle_args *clkspec,
845                                               void *data),
846                         void *data)
847 {
848         return 0;
849 }
850 static inline void of_clk_del_provider(struct device_node *np) {}
851 static inline struct clk *of_clk_src_simple_get(
852         struct of_phandle_args *clkspec, void *data)
853 {
854         return ERR_PTR(-ENOENT);
855 }
856 static inline struct clk_hw *
857 of_clk_hw_simple_get(struct of_phandle_args *clkspec, void *data)
858 {
859         return ERR_PTR(-ENOENT);
860 }
861 static inline struct clk *of_clk_src_onecell_get(
862         struct of_phandle_args *clkspec, void *data)
863 {
864         return ERR_PTR(-ENOENT);
865 }
866 static inline struct clk_hw *
867 of_clk_hw_onecell_get(struct of_phandle_args *clkspec, void *data)
868 {
869         return ERR_PTR(-ENOENT);
870 }
871 static inline unsigned int of_clk_get_parent_count(struct device_node *np)
872 {
873         return 0;
874 }
875 static inline int of_clk_parent_fill(struct device_node *np,
876                                      const char **parents, unsigned int size)
877 {
878         return 0;
879 }
880 static inline const char *of_clk_get_parent_name(struct device_node *np,
881                                                  int index)
882 {
883         return NULL;
884 }
885 static inline int of_clk_detect_critical(struct device_node *np, int index,
886                                           unsigned long *flags)
887 {
888         return 0;
889 }
890 static inline void of_clk_init(const struct of_device_id *matches) {}
891 #endif /* CONFIG_OF */
892
893 /*
894  * wrap access to peripherals in accessor routines
895  * for improved portability across platforms
896  */
897
898 #if IS_ENABLED(CONFIG_PPC)
899
900 static inline u32 clk_readl(u32 __iomem *reg)
901 {
902         return ioread32be(reg);
903 }
904
905 static inline void clk_writel(u32 val, u32 __iomem *reg)
906 {
907         iowrite32be(val, reg);
908 }
909
910 #else   /* platform dependent I/O accessors */
911
912 static inline u32 clk_readl(u32 __iomem *reg)
913 {
914         return readl(reg);
915 }
916
917 static inline void clk_writel(u32 val, u32 __iomem *reg)
918 {
919         writel(val, reg);
920 }
921
922 #endif  /* platform dependent I/O accessors */
923
924 #ifdef CONFIG_DEBUG_FS
925 struct dentry *clk_debugfs_add_file(struct clk_hw *hw, char *name, umode_t mode,
926                                 void *data, const struct file_operations *fops);
927 #endif
928
929 #endif /* CONFIG_COMMON_CLK */
930 #endif /* CLK_PROVIDER_H */