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