1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2016, NVIDIA CORPORATION.
12 #include <reset-uclass.h>
13 #include <dm/devres.h>
16 static inline struct reset_ops *reset_dev_ops(struct udevice *dev)
18 return (struct reset_ops *)dev->driver->ops;
21 static int reset_of_xlate_default(struct reset_ctl *reset_ctl,
22 struct ofnode_phandle_args *args)
24 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
26 if (args->args_count != 1) {
27 debug("Invaild args_count: %d\n", args->args_count);
31 reset_ctl->id = args->args[0];
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)
41 struct udevice *dev_reset;
42 struct reset_ops *ops;
45 reset_ctl->dev = NULL;
49 ret = uclass_get_device_by_ofnode(UCLASS_RESET, args->node,
52 debug("%s: uclass_get_device_by_ofnode() failed: %d\n",
54 debug("%s %d\n", ofnode_get_name(args->node), args->args[0]);
57 ops = reset_dev_ops(dev_reset);
59 reset_ctl->dev = dev_reset;
61 ret = ops->of_xlate(reset_ctl, args);
63 ret = reset_of_xlate_default(reset_ctl, args);
65 debug("of_xlate() failed: %d\n", ret);
69 ret = ops->request(reset_ctl);
71 debug("ops->request() failed: %d\n", ret);
78 int reset_get_by_index(struct udevice *dev, int index,
79 struct reset_ctl *reset_ctl)
81 struct ofnode_phandle_args args;
84 ret = dev_read_phandle_with_args(dev, "resets", "#reset-cells", 0,
87 return reset_get_by_index_tail(ret, dev_ofnode(dev), &args, "resets",
88 index > 0, reset_ctl);
91 int reset_get_by_index_nodev(ofnode node, int index,
92 struct reset_ctl *reset_ctl)
94 struct ofnode_phandle_args args;
97 ret = ofnode_parse_phandle_with_args(node, "resets", "#reset-cells", 0,
100 return reset_get_by_index_tail(ret, node, &args, "resets",
101 index > 0, reset_ctl);
104 static int __reset_get_bulk(struct udevice *dev, ofnode node,
105 struct reset_ctl_bulk *bulk)
107 int i, ret, err, count;
111 count = ofnode_count_phandle_with_args(node, "resets", "#reset-cells",
116 bulk->resets = devm_kcalloc(dev, count, sizeof(struct reset_ctl),
121 for (i = 0; i < count; i++) {
122 ret = reset_get_by_index_nodev(node, i, &bulk->resets[i]);
132 err = reset_release_all(bulk->resets, bulk->count);
134 debug("%s: could release all resets for %p\n",
140 int reset_get_bulk(struct udevice *dev, struct reset_ctl_bulk *bulk)
142 return __reset_get_bulk(dev, dev_ofnode(dev), bulk);
145 int reset_get_by_name(struct udevice *dev, const char *name,
146 struct reset_ctl *reset_ctl)
150 debug("%s(dev=%p, name=%s, reset_ctl=%p)\n", __func__, dev, name,
152 reset_ctl->dev = NULL;
154 index = dev_read_stringlist_search(dev, "reset-names", name);
156 debug("fdt_stringlist_search() failed: %d\n", index);
160 return reset_get_by_index(dev, index, reset_ctl);
163 int reset_request(struct reset_ctl *reset_ctl)
165 struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
167 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
169 return ops->request(reset_ctl);
172 int reset_free(struct reset_ctl *reset_ctl)
174 struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
176 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
178 return ops->rfree(reset_ctl);
181 int reset_assert(struct reset_ctl *reset_ctl)
183 struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
185 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
187 return ops->rst_assert(reset_ctl);
190 int reset_assert_bulk(struct reset_ctl_bulk *bulk)
194 for (i = 0; i < bulk->count; i++) {
195 ret = reset_assert(&bulk->resets[i]);
203 int reset_deassert(struct reset_ctl *reset_ctl)
205 struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
207 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
209 return ops->rst_deassert(reset_ctl);
212 int reset_deassert_bulk(struct reset_ctl_bulk *bulk)
216 for (i = 0; i < bulk->count; i++) {
217 ret = reset_deassert(&bulk->resets[i]);
225 int reset_status(struct reset_ctl *reset_ctl)
227 struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
229 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
231 return ops->rst_status(reset_ctl);
234 int reset_release_all(struct reset_ctl *reset_ctl, int count)
238 for (i = 0; i < count; i++) {
239 debug("%s(reset_ctl[%d]=%p)\n", __func__, i, &reset_ctl[i]);
241 /* check if reset has been previously requested */
242 if (!reset_ctl[i].dev)
245 ret = reset_assert(&reset_ctl[i]);
249 ret = reset_free(&reset_ctl[i]);
257 static void devm_reset_release(struct udevice *dev, void *res)
262 struct reset_ctl *devm_reset_control_get_by_index(struct udevice *dev,
266 struct reset_ctl *reset_ctl;
268 reset_ctl = devres_alloc(devm_reset_release, sizeof(struct reset_ctl),
270 if (unlikely(!reset_ctl))
271 return ERR_PTR(-ENOMEM);
273 rc = reset_get_by_index(dev, index, reset_ctl);
277 devres_add(dev, reset_ctl);
281 struct reset_ctl *devm_reset_control_get(struct udevice *dev, const char *id)
284 struct reset_ctl *reset_ctl;
286 reset_ctl = devres_alloc(devm_reset_release, sizeof(struct reset_ctl),
288 if (unlikely(!reset_ctl))
289 return ERR_PTR(-ENOMEM);
291 rc = reset_get_by_name(dev, id, reset_ctl);
295 devres_add(dev, reset_ctl);
299 struct reset_ctl *devm_reset_control_get_optional(struct udevice *dev,
302 struct reset_ctl *r = devm_reset_control_get(dev, id);
310 static void devm_reset_bulk_release(struct udevice *dev, void *res)
312 struct reset_ctl_bulk *bulk = res;
314 reset_release_all(bulk->resets, bulk->count);
317 struct reset_ctl_bulk *devm_reset_bulk_get_by_node(struct udevice *dev,
321 struct reset_ctl_bulk *bulk;
323 bulk = devres_alloc(devm_reset_bulk_release,
324 sizeof(struct reset_ctl_bulk),
327 return ERR_PTR(-ENOMEM);
329 rc = __reset_get_bulk(dev, node, bulk);
333 devres_add(dev, bulk);
337 struct reset_ctl_bulk *devm_reset_bulk_get_optional_by_node(struct udevice *dev,
340 struct reset_ctl_bulk *bulk;
342 bulk = devm_reset_bulk_get_by_node(dev, node);
350 struct reset_ctl_bulk *devm_reset_bulk_get(struct udevice *dev)
352 return devm_reset_bulk_get_by_node(dev, dev_ofnode(dev));
355 struct reset_ctl_bulk *devm_reset_bulk_get_optional(struct udevice *dev)
357 return devm_reset_bulk_get_optional_by_node(dev, dev_ofnode(dev));
360 UCLASS_DRIVER(reset) = {