]> git.sur5r.net Git - u-boot/blob - drivers/clk/clk-uclass.c
Merge git://git.denx.de/u-boot-sunxi
[u-boot] / drivers / clk / clk-uclass.c
1 /*
2  * Copyright (C) 2015 Google, Inc
3  * Written by Simon Glass <sjg@chromium.org>
4  * Copyright (c) 2016, NVIDIA CORPORATION.
5  *
6  * SPDX-License-Identifier:     GPL-2.0+
7  */
8
9 #include <common.h>
10 #include <clk.h>
11 #include <clk-uclass.h>
12 #include <dm.h>
13 #include <dt-structs.h>
14 #include <errno.h>
15
16 static inline const struct clk_ops *clk_dev_ops(struct udevice *dev)
17 {
18         return (const struct clk_ops *)dev->driver->ops;
19 }
20
21 #if CONFIG_IS_ENABLED(OF_CONTROL)
22 # if CONFIG_IS_ENABLED(OF_PLATDATA)
23 int clk_get_by_index_platdata(struct udevice *dev, int index,
24                               struct phandle_1_arg *cells, struct clk *clk)
25 {
26         int ret;
27
28         if (index != 0)
29                 return -ENOSYS;
30         ret = uclass_get_device(UCLASS_CLK, 0, &clk->dev);
31         if (ret)
32                 return ret;
33         clk->id = cells[0].arg[0];
34
35         return 0;
36 }
37 # else
38 static int clk_of_xlate_default(struct clk *clk,
39                                 struct ofnode_phandle_args *args)
40 {
41         debug("%s(clk=%p)\n", __func__, clk);
42
43         if (args->args_count > 1) {
44                 debug("Invaild args_count: %d\n", args->args_count);
45                 return -EINVAL;
46         }
47
48         if (args->args_count)
49                 clk->id = args->args[0];
50         else
51                 clk->id = 0;
52
53         return 0;
54 }
55
56 int clk_get_by_index(struct udevice *dev, int index, struct clk *clk)
57 {
58         int ret;
59         struct ofnode_phandle_args args;
60         struct udevice *dev_clk;
61         const struct clk_ops *ops;
62
63         debug("%s(dev=%p, index=%d, clk=%p)\n", __func__, dev, index, clk);
64
65         assert(clk);
66         clk->dev = NULL;
67
68         ret = dev_read_phandle_with_args(dev, "clocks", "#clock-cells", 0,
69                                          index, &args);
70         if (ret) {
71                 debug("%s: fdtdec_parse_phandle_with_args failed: err=%d\n",
72                       __func__, ret);
73                 return ret;
74         }
75
76         ret = uclass_get_device_by_ofnode(UCLASS_CLK, args.node, &dev_clk);
77         if (ret) {
78                 debug("%s: uclass_get_device_by_of_offset failed: err=%d\n",
79                       __func__, ret);
80                 return ret;
81         }
82
83         clk->dev = dev_clk;
84
85         ops = clk_dev_ops(dev_clk);
86
87         if (ops->of_xlate)
88                 ret = ops->of_xlate(clk, &args);
89         else
90                 ret = clk_of_xlate_default(clk, &args);
91         if (ret) {
92                 debug("of_xlate() failed: %d\n", ret);
93                 return ret;
94         }
95
96         return clk_request(dev_clk, clk);
97 }
98 # endif /* OF_PLATDATA */
99
100 int clk_get_by_name(struct udevice *dev, const char *name, struct clk *clk)
101 {
102         int index;
103
104         debug("%s(dev=%p, name=%s, clk=%p)\n", __func__, dev, name, clk);
105         clk->dev = NULL;
106
107         index = dev_read_stringlist_search(dev, "clock-names", name);
108         if (index < 0) {
109                 debug("fdt_stringlist_search() failed: %d\n", index);
110                 return index;
111         }
112
113         return clk_get_by_index(dev, index, clk);
114 }
115
116 int clk_release_all(struct clk *clk, int count)
117 {
118         int i, ret;
119
120         for (i = 0; i < count; i++) {
121                 debug("%s(clk[%d]=%p)\n", __func__, i, &clk[i]);
122
123                 /* check if clock has been previously requested */
124                 if (!clk[i].dev)
125                         continue;
126
127                 ret = clk_disable(&clk[i]);
128                 if (ret && ret != -ENOSYS)
129                         return ret;
130
131                 ret = clk_free(&clk[i]);
132                 if (ret && ret != -ENOSYS)
133                         return ret;
134         }
135
136         return 0;
137 }
138
139 #endif /* OF_CONTROL */
140
141 int clk_request(struct udevice *dev, struct clk *clk)
142 {
143         const struct clk_ops *ops = clk_dev_ops(dev);
144
145         debug("%s(dev=%p, clk=%p)\n", __func__, dev, clk);
146
147         clk->dev = dev;
148
149         if (!ops->request)
150                 return 0;
151
152         return ops->request(clk);
153 }
154
155 int clk_free(struct clk *clk)
156 {
157         const struct clk_ops *ops = clk_dev_ops(clk->dev);
158
159         debug("%s(clk=%p)\n", __func__, clk);
160
161         if (!ops->free)
162                 return 0;
163
164         return ops->free(clk);
165 }
166
167 ulong clk_get_rate(struct clk *clk)
168 {
169         const struct clk_ops *ops = clk_dev_ops(clk->dev);
170
171         debug("%s(clk=%p)\n", __func__, clk);
172
173         if (!ops->get_rate)
174                 return -ENOSYS;
175
176         return ops->get_rate(clk);
177 }
178
179 ulong clk_set_rate(struct clk *clk, ulong rate)
180 {
181         const struct clk_ops *ops = clk_dev_ops(clk->dev);
182
183         debug("%s(clk=%p, rate=%lu)\n", __func__, clk, rate);
184
185         if (!ops->set_rate)
186                 return -ENOSYS;
187
188         return ops->set_rate(clk, rate);
189 }
190
191 int clk_enable(struct clk *clk)
192 {
193         const struct clk_ops *ops = clk_dev_ops(clk->dev);
194
195         debug("%s(clk=%p)\n", __func__, clk);
196
197         if (!ops->enable)
198                 return -ENOSYS;
199
200         return ops->enable(clk);
201 }
202
203 int clk_disable(struct clk *clk)
204 {
205         const struct clk_ops *ops = clk_dev_ops(clk->dev);
206
207         debug("%s(clk=%p)\n", __func__, clk);
208
209         if (!ops->disable)
210                 return -ENOSYS;
211
212         return ops->disable(clk);
213 }
214
215 UCLASS_DRIVER(clk) = {
216         .id             = UCLASS_CLK,
217         .name           = "clk",
218 };