include/linux/clk-private.h

   1 /*
   2  *  linux/include/linux/clk-private.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_PRIVATE_H
  12 #define __LINUX_CLK_PRIVATE_H
  13
  14 #include <linux/clk-provider.h>
  15 #include <linux/kref.h>
  16 #include <linux/list.h>
  17
  18 /*
  19  * WARNING: Do not include clk-private.h from any file that implements struct
  20  * clk_ops.  Doing so is a layering violation!
  21  *
  22  * This header exists only to allow for statically initialized clock data.  Any
  23  * static clock data must be defined in a separate file from the logic that
  24  * implements the clock operations for that same data.
  25  */
  26
  27 #ifdef CONFIG_COMMON_CLK
  28
  29 struct module;
  30
  31 struct clk {
  32         const char              *name;
  33         const struct clk_ops    *ops;
  34         struct clk_hw           *hw;
  35         struct module           *owner;
  36         struct clk              *parent;
  37         const char              **parent_names;
  38         struct clk              **parents;
  39         u8                      num_parents;
  40         u8                      new_parent_index;
  41         unsigned long           rate;
  42         unsigned long           new_rate;
  43         struct clk              *new_parent;
  44         struct clk              *new_child;
  45         unsigned long           flags;
  46         unsigned int            enable_count;
  47         unsigned int            prepare_count;
  48         unsigned long           accuracy;
  49         int                     phase;
  50         struct hlist_head       children;
  51         struct hlist_node       child_node;
  52         struct hlist_node       debug_node;
  53         unsigned int            notifier_count;
  54 #ifdef CONFIG_DEBUG_FS
  55         struct dentry           *dentry;
  56 #endif
  57         struct kref             ref;
  58 };
  59
  60 /*
  61  * DOC: Basic clock implementations common to many platforms
  62  *
  63  * Each basic clock hardware type is comprised of a structure describing the
  64  * clock hardware, implementations of the relevant callbacks in struct clk_ops,
  65  * unique flags for that hardware type, a registration function and an
  66  * alternative macro for static initialization
  67  */
  68
  69 #define DEFINE_CLK(_name, _ops, _flags, _parent_names,          \
  70                 _parents)                                       \
  71         static struct clk _name = {                             \
  72                 .name = #_name,                                 \
  73                 .ops = &_ops,                                   \
  74                 .hw = &_name##_hw.hw,                           \
  75                 .parent_names = _parent_names,                  \
  76                 .num_parents = ARRAY_SIZE(_parent_names),       \
  77                 .parents = _parents,                            \
  78                 .flags = _flags | CLK_IS_BASIC,                 \
  79         }
  80
  81 #define DEFINE_CLK_FIXED_RATE(_name, _flags, _rate,             \
  82                                 _fixed_rate_flags)              \
  83         static struct clk _name;                                \
  84         static const char *_name##_parent_names[] = {};         \
  85         static struct clk_fixed_rate _name##_hw = {             \
  86                 .hw = {                                         \
  87                         .clk = &_name,                          \
  88                 },                                              \
  89                 .fixed_rate = _rate,                            \
  90                 .flags = _fixed_rate_flags,                     \
  91         };                                                      \
  92         DEFINE_CLK(_name, clk_fixed_rate_ops, _flags,           \
  93                         _name##_parent_names, NULL);
  94
  95 #define DEFINE_CLK_GATE(_name, _parent_name, _parent_ptr,       \
  96                                 _flags, _reg, _bit_idx,         \
  97                                 _gate_flags, _lock)             \
  98         static struct clk _name;                                \
  99         static const char *_name##_parent_names[] = {           \
 100                 _parent_name,                                   \
 101         };                                                      \
 102         static struct clk *_name##_parents[] = {                \
 103                 _parent_ptr,                                    \
 104         };                                                      \
 105         static struct clk_gate _name##_hw = {                   \
 106                 .hw = {                                         \
 107                         .clk = &_name,                          \
 108                 },                                              \
 109                 .reg = _reg,                                    \
 110                 .bit_idx = _bit_idx,                            \
 111                 .flags = _gate_flags,                           \
 112                 .lock = _lock,                                  \
 113         };                                                      \
 114         DEFINE_CLK(_name, clk_gate_ops, _flags,                 \
 115                         _name##_parent_names, _name##_parents);
 116
 117 #define _DEFINE_CLK_DIVIDER(_name, _parent_name, _parent_ptr,   \
 118                                 _flags, _reg, _shift, _width,   \
 119                                 _divider_flags, _table, _lock)  \
 120         static struct clk _name;                                \
 121         static const char *_name##_parent_names[] = {           \
 122                 _parent_name,                                   \
 123         };                                                      \
 124         static struct clk *_name##_parents[] = {                \
 125                 _parent_ptr,                                    \
 126         };                                                      \
 127         static struct clk_divider _name##_hw = {                \
 128                 .hw = {                                         \
 129                         .clk = &_name,                          \
 130                 },                                              \
 131                 .reg = _reg,                                    \
 132                 .shift = _shift,                                \
 133                 .width = _width,                                \
 134                 .flags = _divider_flags,                        \
 135                 .table = _table,                                \
 136                 .lock = _lock,                                  \
 137         };                                                      \
 138         DEFINE_CLK(_name, clk_divider_ops, _flags,              \
 139                         _name##_parent_names, _name##_parents);
 140
 141 #define DEFINE_CLK_DIVIDER(_name, _parent_name, _parent_ptr,    \
 142                                 _flags, _reg, _shift, _width,   \
 143                                 _divider_flags, _lock)          \
 144         _DEFINE_CLK_DIVIDER(_name, _parent_name, _parent_ptr,   \
 145                                 _flags, _reg, _shift, _width,   \
 146                                 _divider_flags, NULL, _lock)
 147
 148 #define DEFINE_CLK_DIVIDER_TABLE(_name, _parent_name,           \
 149                                 _parent_ptr, _flags, _reg,      \
 150                                 _shift, _width, _divider_flags, \
 151                                 _table, _lock)                  \
 152         _DEFINE_CLK_DIVIDER(_name, _parent_name, _parent_ptr,   \
 153                                 _flags, _reg, _shift, _width,   \
 154                                 _divider_flags, _table, _lock)  \
 155
 156 #define DEFINE_CLK_MUX(_name, _parent_names, _parents, _flags,  \
 157                                 _reg, _shift, _width,           \
 158                                 _mux_flags, _lock)              \
 159         static struct clk _name;                                \
 160         static struct clk_mux _name##_hw = {                    \
 161                 .hw = {                                         \
 162                         .clk = &_name,                          \
 163                 },                                              \
 164                 .reg = _reg,                                    \
 165                 .shift = _shift,                                \
 166                 .mask = BIT(_width) - 1,                        \
 167                 .flags = _mux_flags,                            \
 168                 .lock = _lock,                                  \
 169         };                                                      \
 170         DEFINE_CLK(_name, clk_mux_ops, _flags, _parent_names,   \
 171                         _parents);
 172
 173 #define DEFINE_CLK_FIXED_FACTOR(_name, _parent_name,            \
 174                                 _parent_ptr, _flags,            \
 175                                 _mult, _div)                    \
 176         static struct clk _name;                                \
 177         static const char *_name##_parent_names[] = {           \
 178                 _parent_name,                                   \
 179         };                                                      \
 180         static struct clk *_name##_parents[] = {                \
 181                 _parent_ptr,                                    \
 182         };                                                      \
 183         static struct clk_fixed_factor _name##_hw = {           \
 184                 .hw = {                                         \
 185                         .clk = &_name,                          \
 186                 },                                              \
 187                 .mult = _mult,                                  \
 188                 .div = _div,                                    \
 189         };                                                      \
 190         DEFINE_CLK(_name, clk_fixed_factor_ops, _flags,         \
 191                         _name##_parent_names, _name##_parents);
 192
 193 /**
 194  * __clk_init - initialize the data structures in a struct clk
 195  * @dev:        device initializing this clk, placeholder for now
 196  * @clk:        clk being initialized
 197  *
 198  * Initializes the lists in struct clk, queries the hardware for the
 199  * parent and rate and sets them both.
 200  *
 201  * Any struct clk passed into __clk_init must have the following members
 202  * populated:
 203  *      .name
 204  *      .ops
 205  *      .hw
 206  *      .parent_names
 207  *      .num_parents
 208  *      .flags
 209  *
 210  * It is not necessary to call clk_register if __clk_init is used directly with
 211  * statically initialized clock data.
 212  *
 213  * Returns 0 on success, otherwise an error code.
 214  */
 215 int __clk_init(struct device *dev, struct clk *clk);
 216
 217 struct clk *__clk_register(struct device *dev, struct clk_hw *hw);
 218
 219 #endif /* CONFIG_COMMON_CLK */
 220 #endif /* CLK_PRIVATE_H */