]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
61fc4131 PZ |
2 | #ifndef _LINUX_RESET_H_ |
3 | #define _LINUX_RESET_H_ | |
4 | ||
6c96f05c HG |
5 | #include <linux/device.h> |
6 | ||
61fc4131 PZ |
7 | struct reset_control; |
8 | ||
b424080a PZ |
9 | #ifdef CONFIG_RESET_CONTROLLER |
10 | ||
61fc4131 PZ |
11 | int reset_control_reset(struct reset_control *rstc); |
12 | int reset_control_assert(struct reset_control *rstc); | |
13 | int reset_control_deassert(struct reset_control *rstc); | |
729de41b | 14 | int reset_control_status(struct reset_control *rstc); |
61fc4131 | 15 | |
6c96f05c | 16 | struct reset_control *__of_reset_control_get(struct device_node *node, |
bb475230 RO |
17 | const char *id, int index, bool shared, |
18 | bool optional); | |
62e24c57 PZ |
19 | struct reset_control *__reset_control_get(struct device *dev, const char *id, |
20 | int index, bool shared, | |
21 | bool optional); | |
61fc4131 | 22 | void reset_control_put(struct reset_control *rstc); |
6c96f05c | 23 | struct reset_control *__devm_reset_control_get(struct device *dev, |
bb475230 RO |
24 | const char *id, int index, bool shared, |
25 | bool optional); | |
61fc4131 | 26 | |
b424080a PZ |
27 | int __must_check device_reset(struct device *dev); |
28 | ||
17c82e20 VG |
29 | struct reset_control *devm_reset_control_array_get(struct device *dev, |
30 | bool shared, bool optional); | |
31 | struct reset_control *of_reset_control_array_get(struct device_node *np, | |
32 | bool shared, bool optional); | |
33 | ||
b424080a PZ |
34 | static inline int device_reset_optional(struct device *dev) |
35 | { | |
36 | return device_reset(dev); | |
37 | } | |
38 | ||
b424080a PZ |
39 | #else |
40 | ||
41 | static inline int reset_control_reset(struct reset_control *rstc) | |
42 | { | |
b424080a PZ |
43 | return 0; |
44 | } | |
45 | ||
46 | static inline int reset_control_assert(struct reset_control *rstc) | |
47 | { | |
b424080a PZ |
48 | return 0; |
49 | } | |
50 | ||
51 | static inline int reset_control_deassert(struct reset_control *rstc) | |
52 | { | |
b424080a PZ |
53 | return 0; |
54 | } | |
55 | ||
729de41b DN |
56 | static inline int reset_control_status(struct reset_control *rstc) |
57 | { | |
729de41b DN |
58 | return 0; |
59 | } | |
60 | ||
b424080a PZ |
61 | static inline void reset_control_put(struct reset_control *rstc) |
62 | { | |
b424080a PZ |
63 | } |
64 | ||
41136522 DL |
65 | static inline int __must_check device_reset(struct device *dev) |
66 | { | |
67 | WARN_ON(1); | |
68 | return -ENOTSUPP; | |
69 | } | |
70 | ||
b424080a PZ |
71 | static inline int device_reset_optional(struct device *dev) |
72 | { | |
39b4da71 | 73 | return -ENOTSUPP; |
b424080a PZ |
74 | } |
75 | ||
6c96f05c HG |
76 | static inline struct reset_control *__of_reset_control_get( |
77 | struct device_node *node, | |
bb475230 RO |
78 | const char *id, int index, bool shared, |
79 | bool optional) | |
5bcd0b7f | 80 | { |
0ca10b60 | 81 | return optional ? NULL : ERR_PTR(-ENOTSUPP); |
5bcd0b7f AL |
82 | } |
83 | ||
62e24c57 PZ |
84 | static inline struct reset_control *__reset_control_get( |
85 | struct device *dev, const char *id, | |
86 | int index, bool shared, bool optional) | |
87 | { | |
88 | return optional ? NULL : ERR_PTR(-ENOTSUPP); | |
89 | } | |
90 | ||
6c96f05c | 91 | static inline struct reset_control *__devm_reset_control_get( |
bb475230 RO |
92 | struct device *dev, const char *id, |
93 | int index, bool shared, bool optional) | |
5bcd0b7f | 94 | { |
0ca10b60 | 95 | return optional ? NULL : ERR_PTR(-ENOTSUPP); |
5bcd0b7f AL |
96 | } |
97 | ||
17c82e20 VG |
98 | static inline struct reset_control * |
99 | devm_reset_control_array_get(struct device *dev, bool shared, bool optional) | |
100 | { | |
101 | return optional ? NULL : ERR_PTR(-ENOTSUPP); | |
102 | } | |
103 | ||
104 | static inline struct reset_control * | |
105 | of_reset_control_array_get(struct device_node *np, bool shared, bool optional) | |
106 | { | |
107 | return optional ? NULL : ERR_PTR(-ENOTSUPP); | |
108 | } | |
109 | ||
6c96f05c HG |
110 | #endif /* CONFIG_RESET_CONTROLLER */ |
111 | ||
112 | /** | |
a53e35db LJ |
113 | * reset_control_get_exclusive - Lookup and obtain an exclusive reference |
114 | * to a reset controller. | |
6c96f05c HG |
115 | * @dev: device to be reset by the controller |
116 | * @id: reset line name | |
117 | * | |
118 | * Returns a struct reset_control or IS_ERR() condition containing errno. | |
0b52297f HG |
119 | * If this function is called more then once for the same reset_control it will |
120 | * return -EBUSY. | |
121 | * | |
122 | * See reset_control_get_shared for details on shared references to | |
123 | * reset-controls. | |
6c96f05c HG |
124 | * |
125 | * Use of id names is optional. | |
126 | */ | |
a53e35db LJ |
127 | static inline struct reset_control * |
128 | __must_check reset_control_get_exclusive(struct device *dev, const char *id) | |
b424080a | 129 | { |
6c96f05c HG |
130 | #ifndef CONFIG_RESET_CONTROLLER |
131 | WARN_ON(1); | |
132 | #endif | |
62e24c57 | 133 | return __reset_control_get(dev, id, 0, false, false); |
b424080a PZ |
134 | } |
135 | ||
6c96f05c | 136 | /** |
0b52297f HG |
137 | * reset_control_get_shared - Lookup and obtain a shared reference to a |
138 | * reset controller. | |
139 | * @dev: device to be reset by the controller | |
140 | * @id: reset line name | |
141 | * | |
142 | * Returns a struct reset_control or IS_ERR() condition containing errno. | |
143 | * This function is intended for use with reset-controls which are shared | |
144 | * between hardware-blocks. | |
145 | * | |
146 | * When a reset-control is shared, the behavior of reset_control_assert / | |
147 | * deassert is changed, the reset-core will keep track of a deassert_count | |
148 | * and only (re-)assert the reset after reset_control_assert has been called | |
149 | * as many times as reset_control_deassert was called. Also see the remark | |
150 | * about shared reset-controls in the reset_control_assert docs. | |
151 | * | |
152 | * Calling reset_control_assert without first calling reset_control_deassert | |
153 | * is not allowed on a shared reset control. Calling reset_control_reset is | |
154 | * also not allowed on a shared reset control. | |
155 | * | |
156 | * Use of id names is optional. | |
157 | */ | |
158 | static inline struct reset_control *reset_control_get_shared( | |
159 | struct device *dev, const char *id) | |
160 | { | |
62e24c57 | 161 | return __reset_control_get(dev, id, 0, true, false); |
0b52297f HG |
162 | } |
163 | ||
a53e35db | 164 | static inline struct reset_control *reset_control_get_optional_exclusive( |
3c35f6ed LJ |
165 | struct device *dev, const char *id) |
166 | { | |
62e24c57 | 167 | return __reset_control_get(dev, id, 0, false, true); |
3c35f6ed LJ |
168 | } |
169 | ||
c33d61a0 LJ |
170 | static inline struct reset_control *reset_control_get_optional_shared( |
171 | struct device *dev, const char *id) | |
172 | { | |
62e24c57 | 173 | return __reset_control_get(dev, id, 0, true, true); |
c33d61a0 LJ |
174 | } |
175 | ||
0b52297f | 176 | /** |
a53e35db LJ |
177 | * of_reset_control_get_exclusive - Lookup and obtain an exclusive reference |
178 | * to a reset controller. | |
6c96f05c HG |
179 | * @node: device to be reset by the controller |
180 | * @id: reset line name | |
181 | * | |
182 | * Returns a struct reset_control or IS_ERR() condition containing errno. | |
183 | * | |
184 | * Use of id names is optional. | |
185 | */ | |
a53e35db | 186 | static inline struct reset_control *of_reset_control_get_exclusive( |
e3ec0a8c HG |
187 | struct device_node *node, const char *id) |
188 | { | |
bb475230 | 189 | return __of_reset_control_get(node, id, 0, false, false); |
e3ec0a8c HG |
190 | } |
191 | ||
6c96f05c | 192 | /** |
40faee8e LJ |
193 | * of_reset_control_get_shared - Lookup and obtain an shared reference |
194 | * to a reset controller. | |
195 | * @node: device to be reset by the controller | |
196 | * @id: reset line name | |
197 | * | |
198 | * When a reset-control is shared, the behavior of reset_control_assert / | |
199 | * deassert is changed, the reset-core will keep track of a deassert_count | |
200 | * and only (re-)assert the reset after reset_control_assert has been called | |
201 | * as many times as reset_control_deassert was called. Also see the remark | |
202 | * about shared reset-controls in the reset_control_assert docs. | |
203 | * | |
204 | * Calling reset_control_assert without first calling reset_control_deassert | |
205 | * is not allowed on a shared reset control. Calling reset_control_reset is | |
206 | * also not allowed on a shared reset control. | |
207 | * Returns a struct reset_control or IS_ERR() condition containing errno. | |
208 | * | |
209 | * Use of id names is optional. | |
210 | */ | |
211 | static inline struct reset_control *of_reset_control_get_shared( | |
212 | struct device_node *node, const char *id) | |
213 | { | |
bb475230 | 214 | return __of_reset_control_get(node, id, 0, true, false); |
40faee8e LJ |
215 | } |
216 | ||
6c96f05c | 217 | /** |
a53e35db LJ |
218 | * of_reset_control_get_exclusive_by_index - Lookup and obtain an exclusive |
219 | * reference to a reset controller | |
220 | * by index. | |
6c96f05c HG |
221 | * @node: device to be reset by the controller |
222 | * @index: index of the reset controller | |
223 | * | |
224 | * This is to be used to perform a list of resets for a device or power domain | |
225 | * in whatever order. Returns a struct reset_control or IS_ERR() condition | |
226 | * containing errno. | |
227 | */ | |
a53e35db | 228 | static inline struct reset_control *of_reset_control_get_exclusive_by_index( |
6c96f05c | 229 | struct device_node *node, int index) |
c0a13aa6 | 230 | { |
bb475230 | 231 | return __of_reset_control_get(node, NULL, index, false, false); |
c0a13aa6 VH |
232 | } |
233 | ||
6c96f05c | 234 | /** |
40faee8e LJ |
235 | * of_reset_control_get_shared_by_index - Lookup and obtain an shared |
236 | * reference to a reset controller | |
237 | * by index. | |
238 | * @node: device to be reset by the controller | |
239 | * @index: index of the reset controller | |
240 | * | |
241 | * When a reset-control is shared, the behavior of reset_control_assert / | |
242 | * deassert is changed, the reset-core will keep track of a deassert_count | |
243 | * and only (re-)assert the reset after reset_control_assert has been called | |
244 | * as many times as reset_control_deassert was called. Also see the remark | |
245 | * about shared reset-controls in the reset_control_assert docs. | |
246 | * | |
247 | * Calling reset_control_assert without first calling reset_control_deassert | |
248 | * is not allowed on a shared reset control. Calling reset_control_reset is | |
249 | * also not allowed on a shared reset control. | |
250 | * Returns a struct reset_control or IS_ERR() condition containing errno. | |
6c96f05c | 251 | * |
40faee8e LJ |
252 | * This is to be used to perform a list of resets for a device or power domain |
253 | * in whatever order. Returns a struct reset_control or IS_ERR() condition | |
254 | * containing errno. | |
6c96f05c | 255 | */ |
40faee8e LJ |
256 | static inline struct reset_control *of_reset_control_get_shared_by_index( |
257 | struct device_node *node, int index) | |
6c96f05c | 258 | { |
bb475230 | 259 | return __of_reset_control_get(node, NULL, index, true, false); |
6c96f05c HG |
260 | } |
261 | ||
262 | /** | |
a53e35db LJ |
263 | * devm_reset_control_get_exclusive - resource managed |
264 | * reset_control_get_exclusive() | |
6c96f05c | 265 | * @dev: device to be reset by the controller |
6c96f05c | 266 | * @id: reset line name |
6c96f05c | 267 | * |
a53e35db LJ |
268 | * Managed reset_control_get_exclusive(). For reset controllers returned |
269 | * from this function, reset_control_put() is called automatically on driver | |
270 | * detach. | |
271 | * | |
272 | * See reset_control_get_exclusive() for more information. | |
6c96f05c | 273 | */ |
a53e35db LJ |
274 | static inline struct reset_control * |
275 | __must_check devm_reset_control_get_exclusive(struct device *dev, | |
276 | const char *id) | |
6c96f05c | 277 | { |
6c96f05c HG |
278 | #ifndef CONFIG_RESET_CONTROLLER |
279 | WARN_ON(1); | |
280 | #endif | |
bb475230 | 281 | return __devm_reset_control_get(dev, id, 0, false, false); |
0b52297f HG |
282 | } |
283 | ||
284 | /** | |
285 | * devm_reset_control_get_shared - resource managed reset_control_get_shared() | |
286 | * @dev: device to be reset by the controller | |
287 | * @id: reset line name | |
288 | * | |
289 | * Managed reset_control_get_shared(). For reset controllers returned from | |
290 | * this function, reset_control_put() is called automatically on driver detach. | |
291 | * See reset_control_get_shared() for more information. | |
292 | */ | |
293 | static inline struct reset_control *devm_reset_control_get_shared( | |
294 | struct device *dev, const char *id) | |
295 | { | |
bb475230 | 296 | return __devm_reset_control_get(dev, id, 0, true, false); |
0b52297f HG |
297 | } |
298 | ||
a53e35db | 299 | static inline struct reset_control *devm_reset_control_get_optional_exclusive( |
6c96f05c HG |
300 | struct device *dev, const char *id) |
301 | { | |
bb475230 | 302 | return __devm_reset_control_get(dev, id, 0, false, true); |
6c96f05c HG |
303 | } |
304 | ||
c33d61a0 LJ |
305 | static inline struct reset_control *devm_reset_control_get_optional_shared( |
306 | struct device *dev, const char *id) | |
307 | { | |
bb475230 | 308 | return __devm_reset_control_get(dev, id, 0, true, true); |
c33d61a0 LJ |
309 | } |
310 | ||
6c96f05c | 311 | /** |
a53e35db LJ |
312 | * devm_reset_control_get_exclusive_by_index - resource managed |
313 | * reset_control_get_exclusive() | |
6c96f05c HG |
314 | * @dev: device to be reset by the controller |
315 | * @index: index of the reset controller | |
316 | * | |
a53e35db LJ |
317 | * Managed reset_control_get_exclusive(). For reset controllers returned from |
318 | * this function, reset_control_put() is called automatically on driver | |
319 | * detach. | |
320 | * | |
321 | * See reset_control_get_exclusive() for more information. | |
6c96f05c | 322 | */ |
a53e35db LJ |
323 | static inline struct reset_control * |
324 | devm_reset_control_get_exclusive_by_index(struct device *dev, int index) | |
6c96f05c | 325 | { |
bb475230 | 326 | return __devm_reset_control_get(dev, NULL, index, false, false); |
0b52297f HG |
327 | } |
328 | ||
0b52297f HG |
329 | /** |
330 | * devm_reset_control_get_shared_by_index - resource managed | |
331 | * reset_control_get_shared | |
332 | * @dev: device to be reset by the controller | |
333 | * @index: index of the reset controller | |
334 | * | |
335 | * Managed reset_control_get_shared(). For reset controllers returned from | |
336 | * this function, reset_control_put() is called automatically on driver detach. | |
337 | * See reset_control_get_shared() for more information. | |
338 | */ | |
0bcc0eab LJ |
339 | static inline struct reset_control * |
340 | devm_reset_control_get_shared_by_index(struct device *dev, int index) | |
0b52297f | 341 | { |
bb475230 | 342 | return __devm_reset_control_get(dev, NULL, index, true, false); |
6c96f05c | 343 | } |
61fc4131 | 344 | |
a53e35db LJ |
345 | /* |
346 | * TEMPORARY calls to use during transition: | |
347 | * | |
348 | * of_reset_control_get() => of_reset_control_get_exclusive() | |
349 | * | |
350 | * These inline function calls will be removed once all consumers | |
351 | * have been moved over to the new explicit API. | |
352 | */ | |
353 | static inline struct reset_control *reset_control_get( | |
354 | struct device *dev, const char *id) | |
355 | { | |
356 | return reset_control_get_exclusive(dev, id); | |
357 | } | |
358 | ||
359 | static inline struct reset_control *reset_control_get_optional( | |
360 | struct device *dev, const char *id) | |
361 | { | |
362 | return reset_control_get_optional_exclusive(dev, id); | |
363 | } | |
364 | ||
365 | static inline struct reset_control *of_reset_control_get( | |
366 | struct device_node *node, const char *id) | |
367 | { | |
368 | return of_reset_control_get_exclusive(node, id); | |
369 | } | |
370 | ||
371 | static inline struct reset_control *of_reset_control_get_by_index( | |
372 | struct device_node *node, int index) | |
373 | { | |
374 | return of_reset_control_get_exclusive_by_index(node, index); | |
375 | } | |
376 | ||
377 | static inline struct reset_control *devm_reset_control_get( | |
378 | struct device *dev, const char *id) | |
379 | { | |
380 | return devm_reset_control_get_exclusive(dev, id); | |
381 | } | |
382 | ||
383 | static inline struct reset_control *devm_reset_control_get_optional( | |
384 | struct device *dev, const char *id) | |
385 | { | |
386 | return devm_reset_control_get_optional_exclusive(dev, id); | |
387 | ||
388 | } | |
389 | ||
390 | static inline struct reset_control *devm_reset_control_get_by_index( | |
391 | struct device *dev, int index) | |
392 | { | |
393 | return devm_reset_control_get_exclusive_by_index(dev, index); | |
394 | } | |
17c82e20 VG |
395 | |
396 | /* | |
397 | * APIs to manage a list of reset controllers | |
398 | */ | |
399 | static inline struct reset_control * | |
400 | devm_reset_control_array_get_exclusive(struct device *dev) | |
401 | { | |
402 | return devm_reset_control_array_get(dev, false, false); | |
403 | } | |
404 | ||
405 | static inline struct reset_control * | |
406 | devm_reset_control_array_get_shared(struct device *dev) | |
407 | { | |
408 | return devm_reset_control_array_get(dev, true, false); | |
409 | } | |
410 | ||
411 | static inline struct reset_control * | |
412 | devm_reset_control_array_get_optional_exclusive(struct device *dev) | |
413 | { | |
414 | return devm_reset_control_array_get(dev, false, true); | |
415 | } | |
416 | ||
417 | static inline struct reset_control * | |
418 | devm_reset_control_array_get_optional_shared(struct device *dev) | |
419 | { | |
420 | return devm_reset_control_array_get(dev, true, true); | |
421 | } | |
422 | ||
423 | static inline struct reset_control * | |
424 | of_reset_control_array_get_exclusive(struct device_node *node) | |
425 | { | |
426 | return of_reset_control_array_get(node, false, false); | |
427 | } | |
428 | ||
429 | static inline struct reset_control * | |
430 | of_reset_control_array_get_shared(struct device_node *node) | |
431 | { | |
432 | return of_reset_control_array_get(node, true, false); | |
433 | } | |
434 | ||
435 | static inline struct reset_control * | |
436 | of_reset_control_array_get_optional_exclusive(struct device_node *node) | |
437 | { | |
438 | return of_reset_control_array_get(node, false, true); | |
439 | } | |
440 | ||
441 | static inline struct reset_control * | |
442 | of_reset_control_array_get_optional_shared(struct device_node *node) | |
443 | { | |
444 | return of_reset_control_array_get(node, true, true); | |
445 | } | |
61fc4131 | 446 | #endif |