1 /*
2 * Copyright (c) 2016, NVIDIA CORPORATION.
3 *
4 * SPDX-License-Identifier: GPL-2.0
5 */
6
7 #include <common.h>
8 #include <dm.h>
9 #include <fdtdec.h>
10 #include <reset.h>
11 #include <reset-uclass.h>
12
13 DECLARE_GLOBAL_DATA_PTR;
14
reset_dev_ops(struct udevice * dev)15 static inline struct reset_ops *reset_dev_ops(struct udevice *dev)
16 {
17 return (struct reset_ops *)dev->driver->ops;
18 }
19
reset_of_xlate_default(struct reset_ctl * reset_ctl,struct ofnode_phandle_args * args)20 static int reset_of_xlate_default(struct reset_ctl *reset_ctl,
21 struct ofnode_phandle_args *args)
22 {
23 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
24
25 if (args->args_count != 1) {
26 debug("Invaild args_count: %d\n", args->args_count);
27 return -EINVAL;
28 }
29
30 reset_ctl->id = args->args[0];
31
32 return 0;
33 }
34
reset_get_by_index(struct udevice * dev,int index,struct reset_ctl * reset_ctl)35 int reset_get_by_index(struct udevice *dev, int index,
36 struct reset_ctl *reset_ctl)
37 {
38 struct ofnode_phandle_args args;
39 int ret;
40 struct udevice *dev_reset;
41 struct reset_ops *ops;
42
43 debug("%s(dev=%p, index=%d, reset_ctl=%p)\n", __func__, dev, index,
44 reset_ctl);
45 reset_ctl->dev = NULL;
46
47 ret = dev_read_phandle_with_args(dev, "resets", "#reset-cells", 0,
48 index, &args);
49 if (ret) {
50 debug("%s: fdtdec_parse_phandle_with_args() failed: %d\n",
51 __func__, ret);
52 return ret;
53 }
54
55 ret = uclass_get_device_by_ofnode(UCLASS_RESET, args.node,
56 &dev_reset);
57 if (ret) {
58 debug("%s: uclass_get_device_by_ofnode() failed: %d\n",
59 __func__, ret);
60 debug("%s %d\n", ofnode_get_name(args.node), args.args[0]);
61 return ret;
62 }
63 ops = reset_dev_ops(dev_reset);
64
65 reset_ctl->dev = dev_reset;
66 if (ops->of_xlate)
67 ret = ops->of_xlate(reset_ctl, &args);
68 else
69 ret = reset_of_xlate_default(reset_ctl, &args);
70 if (ret) {
71 debug("of_xlate() failed: %d\n", ret);
72 return ret;
73 }
74
75 ret = ops->request(reset_ctl);
76 if (ret) {
77 debug("ops->request() failed: %d\n", ret);
78 return ret;
79 }
80
81 return 0;
82 }
83
reset_get_bulk(struct udevice * dev,struct reset_ctl_bulk * bulk)84 int reset_get_bulk(struct udevice *dev, struct reset_ctl_bulk *bulk)
85 {
86 int i, ret, err, count;
87
88 bulk->count = 0;
89
90 count = dev_count_phandle_with_args(dev, "resets", "#reset-cells");
91 if (count < 1)
92 return count;
93
94 bulk->resets = devm_kcalloc(dev, count, sizeof(struct reset_ctl),
95 GFP_KERNEL);
96 if (!bulk->resets)
97 return -ENOMEM;
98
99 for (i = 0; i < count; i++) {
100 ret = reset_get_by_index(dev, i, &bulk->resets[i]);
101 if (ret < 0)
102 goto bulk_get_err;
103
104 ++bulk->count;
105 }
106
107 return 0;
108
109 bulk_get_err:
110 err = reset_release_all(bulk->resets, bulk->count);
111 if (err)
112 debug("%s: could release all resets for %p\n",
113 __func__, dev);
114
115 return ret;
116 }
117
reset_get_by_name(struct udevice * dev,const char * name,struct reset_ctl * reset_ctl)118 int reset_get_by_name(struct udevice *dev, const char *name,
119 struct reset_ctl *reset_ctl)
120 {
121 int index;
122
123 debug("%s(dev=%p, name=%s, reset_ctl=%p)\n", __func__, dev, name,
124 reset_ctl);
125 reset_ctl->dev = NULL;
126
127 index = dev_read_stringlist_search(dev, "reset-names", name);
128 if (index < 0) {
129 debug("fdt_stringlist_search() failed: %d\n", index);
130 return index;
131 }
132
133 return reset_get_by_index(dev, index, reset_ctl);
134 }
135
reset_request(struct reset_ctl * reset_ctl)136 int reset_request(struct reset_ctl *reset_ctl)
137 {
138 struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
139
140 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
141
142 return ops->request(reset_ctl);
143 }
144
reset_free(struct reset_ctl * reset_ctl)145 int reset_free(struct reset_ctl *reset_ctl)
146 {
147 struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
148
149 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
150
151 return ops->free(reset_ctl);
152 }
153
reset_assert(struct reset_ctl * reset_ctl)154 int reset_assert(struct reset_ctl *reset_ctl)
155 {
156 struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
157
158 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
159
160 return ops->rst_assert(reset_ctl);
161 }
162
reset_assert_bulk(struct reset_ctl_bulk * bulk)163 int reset_assert_bulk(struct reset_ctl_bulk *bulk)
164 {
165 int i, ret;
166
167 for (i = 0; i < bulk->count; i++) {
168 ret = reset_assert(&bulk->resets[i]);
169 if (ret < 0)
170 return ret;
171 }
172
173 return 0;
174 }
175
reset_deassert(struct reset_ctl * reset_ctl)176 int reset_deassert(struct reset_ctl *reset_ctl)
177 {
178 struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
179
180 debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
181
182 return ops->rst_deassert(reset_ctl);
183 }
184
reset_deassert_bulk(struct reset_ctl_bulk * bulk)185 int reset_deassert_bulk(struct reset_ctl_bulk *bulk)
186 {
187 int i, ret;
188
189 for (i = 0; i < bulk->count; i++) {
190 ret = reset_deassert(&bulk->resets[i]);
191 if (ret < 0)
192 return ret;
193 }
194
195 return 0;
196 }
197
reset_release_all(struct reset_ctl * reset_ctl,int count)198 int reset_release_all(struct reset_ctl *reset_ctl, int count)
199 {
200 int i, ret;
201
202 for (i = 0; i < count; i++) {
203 debug("%s(reset_ctl[%d]=%p)\n", __func__, i, &reset_ctl[i]);
204
205 /* check if reset has been previously requested */
206 if (!reset_ctl[i].dev)
207 continue;
208
209 ret = reset_assert(&reset_ctl[i]);
210 if (ret)
211 return ret;
212
213 ret = reset_free(&reset_ctl[i]);
214 if (ret)
215 return ret;
216 }
217
218 return 0;
219 }
220
221 UCLASS_DRIVER(reset) = {
222 .id = UCLASS_RESET,
223 .name = "reset",
224 };
225