1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2016, NVIDIA CORPORATION.
4 */
5
6 #include <common.h>
7 #include <dm.h>
8 #include <fdtdec.h>
9 #include <log.h>
10 #include <malloc.h>
11 #include <reset.h>
12 #include <reset-uclass.h>
13 #include <dm/devres.h>
14 #include <dm/lists.h>
15
reset_dev_ops(struct udevice * dev)16 static inline struct reset_ops *reset_dev_ops(struct udevice *dev)
17 {
18 return (struct reset_ops *)dev->driver->ops;
19 }
20
reset_of_xlate_default(struct reset_ctl * reset_ctl,struct ofnode_phandle_args * args)21 static int reset_of_xlate_default(struct reset_ctl *reset_ctl,
22 struct ofnode_phandle_args *args)
23 {
24 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
25
26 if (args->args_count != 1) {
27 debug("Invaild args_count: %d\n", args->args_count);
28 return -EINVAL;
29 }
30
31 reset_ctl->id = args->args[0];
32
33 return 0;
34 }
35
reset_get_by_index_tail(int ret,ofnode node,struct ofnode_phandle_args * args,const char * list_name,int index,struct reset_ctl * reset_ctl)36 static int reset_get_by_index_tail(int ret, ofnode node,
37 struct ofnode_phandle_args *args,
38 const char *list_name, int index,
39 struct reset_ctl *reset_ctl)
40 {
41 struct udevice *dev_reset;
42 struct reset_ops *ops;
43
44 assert(reset_ctl);
45 reset_ctl->dev = NULL;
46 if (ret)
47 return ret;
48
49 ret = uclass_get_device_by_ofnode(UCLASS_RESET, args->node,
50 &dev_reset);
51 if (ret) {
52 debug("%s: uclass_get_device_by_ofnode() failed: %d\n",
53 __func__, ret);
54 debug("%s %d\n", ofnode_get_name(args->node), args->args[0]);
55 return ret;
56 }
57 ops = reset_dev_ops(dev_reset);
58
59 reset_ctl->dev = dev_reset;
60 if (ops->of_xlate)
61 ret = ops->of_xlate(reset_ctl, args);
62 else
63 ret = reset_of_xlate_default(reset_ctl, args);
64 if (ret) {
65 debug("of_xlate() failed: %d\n", ret);
66 return ret;
67 }
68
69 ret = ops->request(reset_ctl);
70 if (ret) {
71 debug("ops->request() failed: %d\n", ret);
72 return ret;
73 }
74
75 return 0;
76 }
77
reset_get_by_index(struct udevice * dev,int index,struct reset_ctl * reset_ctl)78 int reset_get_by_index(struct udevice *dev, int index,
79 struct reset_ctl *reset_ctl)
80 {
81 struct ofnode_phandle_args args;
82 int ret;
83
84 ret = dev_read_phandle_with_args(dev, "resets", "#reset-cells", 0,
85 index, &args);
86
87 return reset_get_by_index_tail(ret, dev_ofnode(dev), &args, "resets",
88 index > 0, reset_ctl);
89 }
90
reset_get_by_index_nodev(ofnode node,int index,struct reset_ctl * reset_ctl)91 int reset_get_by_index_nodev(ofnode node, int index,
92 struct reset_ctl *reset_ctl)
93 {
94 struct ofnode_phandle_args args;
95 int ret;
96
97 ret = ofnode_parse_phandle_with_args(node, "resets", "#reset-cells", 0,
98 index, &args);
99
100 return reset_get_by_index_tail(ret, node, &args, "resets",
101 index > 0, reset_ctl);
102 }
103
__reset_get_bulk(struct udevice * dev,ofnode node,struct reset_ctl_bulk * bulk)104 static int __reset_get_bulk(struct udevice *dev, ofnode node,
105 struct reset_ctl_bulk *bulk)
106 {
107 int i, ret, err, count;
108
109 bulk->count = 0;
110
111 count = ofnode_count_phandle_with_args(node, "resets", "#reset-cells",
112 0);
113 if (count < 1)
114 return count;
115
116 bulk->resets = devm_kcalloc(dev, count, sizeof(struct reset_ctl),
117 GFP_KERNEL);
118 if (!bulk->resets)
119 return -ENOMEM;
120
121 for (i = 0; i < count; i++) {
122 ret = reset_get_by_index_nodev(node, i, &bulk->resets[i]);
123 if (ret < 0)
124 goto bulk_get_err;
125
126 ++bulk->count;
127 }
128
129 return 0;
130
131 bulk_get_err:
132 err = reset_release_all(bulk->resets, bulk->count);
133 if (err)
134 debug("%s: could release all resets for %p\n",
135 __func__, dev);
136
137 return ret;
138 }
139
reset_get_bulk(struct udevice * dev,struct reset_ctl_bulk * bulk)140 int reset_get_bulk(struct udevice *dev, struct reset_ctl_bulk *bulk)
141 {
142 return __reset_get_bulk(dev, dev_ofnode(dev), bulk);
143 }
144
reset_get_by_name(struct udevice * dev,const char * name,struct reset_ctl * reset_ctl)145 int reset_get_by_name(struct udevice *dev, const char *name,
146 struct reset_ctl *reset_ctl)
147 {
148 int index;
149
150 debug("%s(dev=%p, name=%s, reset_ctl=%p)\n", __func__, dev, name,
151 reset_ctl);
152 reset_ctl->dev = NULL;
153
154 index = dev_read_stringlist_search(dev, "reset-names", name);
155 if (index < 0) {
156 debug("fdt_stringlist_search() failed: %d\n", index);
157 return index;
158 }
159
160 return reset_get_by_index(dev, index, reset_ctl);
161 }
162
reset_request(struct reset_ctl * reset_ctl)163 int reset_request(struct reset_ctl *reset_ctl)
164 {
165 struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
166
167 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
168
169 return ops->request(reset_ctl);
170 }
171
reset_free(struct reset_ctl * reset_ctl)172 int reset_free(struct reset_ctl *reset_ctl)
173 {
174 struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
175
176 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
177
178 return ops->rfree(reset_ctl);
179 }
180
reset_assert(struct reset_ctl * reset_ctl)181 int reset_assert(struct reset_ctl *reset_ctl)
182 {
183 struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
184
185 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
186
187 return ops->rst_assert(reset_ctl);
188 }
189
reset_assert_bulk(struct reset_ctl_bulk * bulk)190 int reset_assert_bulk(struct reset_ctl_bulk *bulk)
191 {
192 int i, ret;
193
194 for (i = 0; i < bulk->count; i++) {
195 ret = reset_assert(&bulk->resets[i]);
196 if (ret < 0)
197 return ret;
198 }
199
200 return 0;
201 }
202
reset_deassert(struct reset_ctl * reset_ctl)203 int reset_deassert(struct reset_ctl *reset_ctl)
204 {
205 struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
206
207 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
208
209 return ops->rst_deassert(reset_ctl);
210 }
211
reset_deassert_bulk(struct reset_ctl_bulk * bulk)212 int reset_deassert_bulk(struct reset_ctl_bulk *bulk)
213 {
214 int i, ret;
215
216 for (i = 0; i < bulk->count; i++) {
217 ret = reset_deassert(&bulk->resets[i]);
218 if (ret < 0)
219 return ret;
220 }
221
222 return 0;
223 }
224
reset_status(struct reset_ctl * reset_ctl)225 int reset_status(struct reset_ctl *reset_ctl)
226 {
227 struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
228
229 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
230
231 return ops->rst_status(reset_ctl);
232 }
233
reset_release_all(struct reset_ctl * reset_ctl,int count)234 int reset_release_all(struct reset_ctl *reset_ctl, int count)
235 {
236 int i, ret;
237
238 for (i = 0; i < count; i++) {
239 debug("%s(reset_ctl[%d]=%p)\n", __func__, i, &reset_ctl[i]);
240
241 /* check if reset has been previously requested */
242 if (!reset_ctl[i].dev)
243 continue;
244
245 ret = reset_assert(&reset_ctl[i]);
246 if (ret)
247 return ret;
248
249 ret = reset_free(&reset_ctl[i]);
250 if (ret)
251 return ret;
252 }
253
254 return 0;
255 }
256
devm_reset_release(struct udevice * dev,void * res)257 static void devm_reset_release(struct udevice *dev, void *res)
258 {
259 reset_free(res);
260 }
261
devm_reset_control_get_by_index(struct udevice * dev,int index)262 struct reset_ctl *devm_reset_control_get_by_index(struct udevice *dev,
263 int index)
264 {
265 int rc;
266 struct reset_ctl *reset_ctl;
267
268 reset_ctl = devres_alloc(devm_reset_release, sizeof(struct reset_ctl),
269 __GFP_ZERO);
270 if (unlikely(!reset_ctl))
271 return ERR_PTR(-ENOMEM);
272
273 rc = reset_get_by_index(dev, index, reset_ctl);
274 if (rc)
275 return ERR_PTR(rc);
276
277 devres_add(dev, reset_ctl);
278 return reset_ctl;
279 }
280
devm_reset_control_get(struct udevice * dev,const char * id)281 struct reset_ctl *devm_reset_control_get(struct udevice *dev, const char *id)
282 {
283 int rc;
284 struct reset_ctl *reset_ctl;
285
286 reset_ctl = devres_alloc(devm_reset_release, sizeof(struct reset_ctl),
287 __GFP_ZERO);
288 if (unlikely(!reset_ctl))
289 return ERR_PTR(-ENOMEM);
290
291 rc = reset_get_by_name(dev, id, reset_ctl);
292 if (rc)
293 return ERR_PTR(rc);
294
295 devres_add(dev, reset_ctl);
296 return reset_ctl;
297 }
298
devm_reset_control_get_optional(struct udevice * dev,const char * id)299 struct reset_ctl *devm_reset_control_get_optional(struct udevice *dev,
300 const char *id)
301 {
302 struct reset_ctl *r = devm_reset_control_get(dev, id);
303
304 if (IS_ERR(r))
305 return NULL;
306
307 return r;
308 }
309
devm_reset_bulk_release(struct udevice * dev,void * res)310 static void devm_reset_bulk_release(struct udevice *dev, void *res)
311 {
312 struct reset_ctl_bulk *bulk = res;
313
314 reset_release_all(bulk->resets, bulk->count);
315 }
316
devm_reset_bulk_get_by_node(struct udevice * dev,ofnode node)317 struct reset_ctl_bulk *devm_reset_bulk_get_by_node(struct udevice *dev,
318 ofnode node)
319 {
320 int rc;
321 struct reset_ctl_bulk *bulk;
322
323 bulk = devres_alloc(devm_reset_bulk_release,
324 sizeof(struct reset_ctl_bulk),
325 __GFP_ZERO);
326 if (unlikely(!bulk))
327 return ERR_PTR(-ENOMEM);
328
329 rc = __reset_get_bulk(dev, node, bulk);
330 if (rc)
331 return ERR_PTR(rc);
332
333 devres_add(dev, bulk);
334 return bulk;
335 }
336
devm_reset_bulk_get_optional_by_node(struct udevice * dev,ofnode node)337 struct reset_ctl_bulk *devm_reset_bulk_get_optional_by_node(struct udevice *dev,
338 ofnode node)
339 {
340 struct reset_ctl_bulk *bulk;
341
342 bulk = devm_reset_bulk_get_by_node(dev, node);
343
344 if (IS_ERR(bulk))
345 return NULL;
346
347 return bulk;
348 }
349
devm_reset_bulk_get(struct udevice * dev)350 struct reset_ctl_bulk *devm_reset_bulk_get(struct udevice *dev)
351 {
352 return devm_reset_bulk_get_by_node(dev, dev_ofnode(dev));
353 }
354
devm_reset_bulk_get_optional(struct udevice * dev)355 struct reset_ctl_bulk *devm_reset_bulk_get_optional(struct udevice *dev)
356 {
357 return devm_reset_bulk_get_optional_by_node(dev, dev_ofnode(dev));
358 }
359
360 UCLASS_DRIVER(reset) = {
361 .id = UCLASS_RESET,
362 .name = "reset",
363 };
364