1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | #ifndef _LINUX_RESET_H_ |
3 | #define _LINUX_RESET_H_ |
4 | |
5 | #include <linux/err.h> |
6 | #include <linux/errno.h> |
7 | #include <linux/types.h> |
8 | |
9 | struct device; |
10 | struct device_node; |
11 | struct reset_control; |
12 | |
13 | /** |
14 | * struct reset_control_bulk_data - Data used for bulk reset control operations. |
15 | * |
16 | * @id: reset control consumer ID |
17 | * @rstc: struct reset_control * to store the associated reset control |
18 | * |
19 | * The reset APIs provide a series of reset_control_bulk_*() API calls as |
20 | * a convenience to consumers which require multiple reset controls. |
21 | * This structure is used to manage data for these calls. |
22 | */ |
23 | struct reset_control_bulk_data { |
24 | const char *id; |
25 | struct reset_control *rstc; |
26 | }; |
27 | |
28 | #ifdef CONFIG_RESET_CONTROLLER |
29 | |
30 | int reset_control_reset(struct reset_control *rstc); |
31 | int reset_control_rearm(struct reset_control *rstc); |
32 | int reset_control_assert(struct reset_control *rstc); |
33 | int reset_control_deassert(struct reset_control *rstc); |
34 | int reset_control_status(struct reset_control *rstc); |
35 | int reset_control_acquire(struct reset_control *rstc); |
36 | void reset_control_release(struct reset_control *rstc); |
37 | |
38 | int reset_control_bulk_reset(int num_rstcs, struct reset_control_bulk_data *rstcs); |
39 | int reset_control_bulk_assert(int num_rstcs, struct reset_control_bulk_data *rstcs); |
40 | int reset_control_bulk_deassert(int num_rstcs, struct reset_control_bulk_data *rstcs); |
41 | int reset_control_bulk_acquire(int num_rstcs, struct reset_control_bulk_data *rstcs); |
42 | void reset_control_bulk_release(int num_rstcs, struct reset_control_bulk_data *rstcs); |
43 | |
44 | struct reset_control *__of_reset_control_get(struct device_node *node, |
45 | const char *id, int index, bool shared, |
46 | bool optional, bool acquired); |
47 | struct reset_control *__reset_control_get(struct device *dev, const char *id, |
48 | int index, bool shared, |
49 | bool optional, bool acquired); |
50 | void reset_control_put(struct reset_control *rstc); |
51 | int __reset_control_bulk_get(struct device *dev, int num_rstcs, |
52 | struct reset_control_bulk_data *rstcs, |
53 | bool shared, bool optional, bool acquired); |
54 | void reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs); |
55 | |
56 | int __device_reset(struct device *dev, bool optional); |
57 | struct reset_control *__devm_reset_control_get(struct device *dev, |
58 | const char *id, int index, bool shared, |
59 | bool optional, bool acquired); |
60 | int __devm_reset_control_bulk_get(struct device *dev, int num_rstcs, |
61 | struct reset_control_bulk_data *rstcs, |
62 | bool shared, bool optional, bool acquired); |
63 | |
64 | struct reset_control *devm_reset_control_array_get(struct device *dev, |
65 | bool shared, bool optional); |
66 | struct reset_control *of_reset_control_array_get(struct device_node *np, |
67 | bool shared, bool optional, |
68 | bool acquired); |
69 | |
70 | int reset_control_get_count(struct device *dev); |
71 | |
72 | #else |
73 | |
74 | static inline int reset_control_reset(struct reset_control *rstc) |
75 | { |
76 | return 0; |
77 | } |
78 | |
79 | static inline int reset_control_rearm(struct reset_control *rstc) |
80 | { |
81 | return 0; |
82 | } |
83 | |
84 | static inline int reset_control_assert(struct reset_control *rstc) |
85 | { |
86 | return 0; |
87 | } |
88 | |
89 | static inline int reset_control_deassert(struct reset_control *rstc) |
90 | { |
91 | return 0; |
92 | } |
93 | |
94 | static inline int reset_control_status(struct reset_control *rstc) |
95 | { |
96 | return 0; |
97 | } |
98 | |
99 | static inline int reset_control_acquire(struct reset_control *rstc) |
100 | { |
101 | return 0; |
102 | } |
103 | |
104 | static inline void reset_control_release(struct reset_control *rstc) |
105 | { |
106 | } |
107 | |
108 | static inline void reset_control_put(struct reset_control *rstc) |
109 | { |
110 | } |
111 | |
112 | static inline int __device_reset(struct device *dev, bool optional) |
113 | { |
114 | return optional ? 0 : -ENOTSUPP; |
115 | } |
116 | |
117 | static inline struct reset_control *__of_reset_control_get( |
118 | struct device_node *node, |
119 | const char *id, int index, bool shared, |
120 | bool optional, bool acquired) |
121 | { |
122 | return optional ? NULL : ERR_PTR(-ENOTSUPP); |
123 | } |
124 | |
125 | static inline struct reset_control *__reset_control_get( |
126 | struct device *dev, const char *id, |
127 | int index, bool shared, bool optional, |
128 | bool acquired) |
129 | { |
130 | return optional ? NULL : ERR_PTR(-ENOTSUPP); |
131 | } |
132 | |
133 | static inline int |
134 | reset_control_bulk_reset(int num_rstcs, struct reset_control_bulk_data *rstcs) |
135 | { |
136 | return 0; |
137 | } |
138 | |
139 | static inline int |
140 | reset_control_bulk_assert(int num_rstcs, struct reset_control_bulk_data *rstcs) |
141 | { |
142 | return 0; |
143 | } |
144 | |
145 | static inline int |
146 | reset_control_bulk_deassert(int num_rstcs, struct reset_control_bulk_data *rstcs) |
147 | { |
148 | return 0; |
149 | } |
150 | |
151 | static inline int |
152 | reset_control_bulk_acquire(int num_rstcs, struct reset_control_bulk_data *rstcs) |
153 | { |
154 | return 0; |
155 | } |
156 | |
157 | static inline void |
158 | reset_control_bulk_release(int num_rstcs, struct reset_control_bulk_data *rstcs) |
159 | { |
160 | } |
161 | |
162 | static inline int |
163 | __reset_control_bulk_get(struct device *dev, int num_rstcs, |
164 | struct reset_control_bulk_data *rstcs, |
165 | bool shared, bool optional, bool acquired) |
166 | { |
167 | return optional ? 0 : -EOPNOTSUPP; |
168 | } |
169 | |
170 | static inline void |
171 | reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs) |
172 | { |
173 | } |
174 | |
175 | static inline struct reset_control *__devm_reset_control_get( |
176 | struct device *dev, const char *id, |
177 | int index, bool shared, bool optional, |
178 | bool acquired) |
179 | { |
180 | return optional ? NULL : ERR_PTR(-ENOTSUPP); |
181 | } |
182 | |
183 | static inline int |
184 | __devm_reset_control_bulk_get(struct device *dev, int num_rstcs, |
185 | struct reset_control_bulk_data *rstcs, |
186 | bool shared, bool optional, bool acquired) |
187 | { |
188 | return optional ? 0 : -EOPNOTSUPP; |
189 | } |
190 | |
191 | static inline struct reset_control * |
192 | devm_reset_control_array_get(struct device *dev, bool shared, bool optional) |
193 | { |
194 | return optional ? NULL : ERR_PTR(-ENOTSUPP); |
195 | } |
196 | |
197 | static inline struct reset_control * |
198 | of_reset_control_array_get(struct device_node *np, bool shared, bool optional, |
199 | bool acquired) |
200 | { |
201 | return optional ? NULL : ERR_PTR(-ENOTSUPP); |
202 | } |
203 | |
204 | static inline int reset_control_get_count(struct device *dev) |
205 | { |
206 | return -ENOENT; |
207 | } |
208 | |
209 | #endif /* CONFIG_RESET_CONTROLLER */ |
210 | |
211 | static inline int __must_check device_reset(struct device *dev) |
212 | { |
213 | return __device_reset(dev, optional: false); |
214 | } |
215 | |
216 | static inline int device_reset_optional(struct device *dev) |
217 | { |
218 | return __device_reset(dev, optional: true); |
219 | } |
220 | |
221 | /** |
222 | * reset_control_get_exclusive - Lookup and obtain an exclusive reference |
223 | * to a reset controller. |
224 | * @dev: device to be reset by the controller |
225 | * @id: reset line name |
226 | * |
227 | * Returns a struct reset_control or IS_ERR() condition containing errno. |
228 | * If this function is called more than once for the same reset_control it will |
229 | * return -EBUSY. |
230 | * |
231 | * See reset_control_get_shared() for details on shared references to |
232 | * reset-controls. |
233 | * |
234 | * Use of id names is optional. |
235 | */ |
236 | static inline struct reset_control * |
237 | __must_check reset_control_get_exclusive(struct device *dev, const char *id) |
238 | { |
239 | return __reset_control_get(dev, id, index: 0, shared: false, optional: false, acquired: true); |
240 | } |
241 | |
242 | /** |
243 | * reset_control_bulk_get_exclusive - Lookup and obtain exclusive references to |
244 | * multiple reset controllers. |
245 | * @dev: device to be reset by the controller |
246 | * @num_rstcs: number of entries in rstcs array |
247 | * @rstcs: array of struct reset_control_bulk_data with reset line names set |
248 | * |
249 | * Fills the rstcs array with pointers to exclusive reset controls and |
250 | * returns 0, or an IS_ERR() condition containing errno. |
251 | */ |
252 | static inline int __must_check |
253 | reset_control_bulk_get_exclusive(struct device *dev, int num_rstcs, |
254 | struct reset_control_bulk_data *rstcs) |
255 | { |
256 | return __reset_control_bulk_get(dev, num_rstcs, rstcs, shared: false, optional: false, acquired: true); |
257 | } |
258 | |
259 | /** |
260 | * reset_control_get_exclusive_released - Lookup and obtain a temoprarily |
261 | * exclusive reference to a reset |
262 | * controller. |
263 | * @dev: device to be reset by the controller |
264 | * @id: reset line name |
265 | * |
266 | * Returns a struct reset_control or IS_ERR() condition containing errno. |
267 | * reset-controls returned by this function must be acquired via |
268 | * reset_control_acquire() before they can be used and should be released |
269 | * via reset_control_release() afterwards. |
270 | * |
271 | * Use of id names is optional. |
272 | */ |
273 | static inline struct reset_control * |
274 | __must_check reset_control_get_exclusive_released(struct device *dev, |
275 | const char *id) |
276 | { |
277 | return __reset_control_get(dev, id, index: 0, shared: false, optional: false, acquired: false); |
278 | } |
279 | |
280 | /** |
281 | * reset_control_bulk_get_exclusive_released - Lookup and obtain temporarily |
282 | * exclusive references to multiple reset |
283 | * controllers. |
284 | * @dev: device to be reset by the controller |
285 | * @num_rstcs: number of entries in rstcs array |
286 | * @rstcs: array of struct reset_control_bulk_data with reset line names set |
287 | * |
288 | * Fills the rstcs array with pointers to exclusive reset controls and |
289 | * returns 0, or an IS_ERR() condition containing errno. |
290 | * reset-controls returned by this function must be acquired via |
291 | * reset_control_bulk_acquire() before they can be used and should be released |
292 | * via reset_control_bulk_release() afterwards. |
293 | */ |
294 | static inline int __must_check |
295 | reset_control_bulk_get_exclusive_released(struct device *dev, int num_rstcs, |
296 | struct reset_control_bulk_data *rstcs) |
297 | { |
298 | return __reset_control_bulk_get(dev, num_rstcs, rstcs, shared: false, optional: false, acquired: false); |
299 | } |
300 | |
301 | /** |
302 | * reset_control_bulk_get_optional_exclusive_released - Lookup and obtain optional |
303 | * temporarily exclusive references to multiple |
304 | * reset controllers. |
305 | * @dev: device to be reset by the controller |
306 | * @num_rstcs: number of entries in rstcs array |
307 | * @rstcs: array of struct reset_control_bulk_data with reset line names set |
308 | * |
309 | * Optional variant of reset_control_bulk_get_exclusive_released(). If the |
310 | * requested reset is not specified in the device tree, this function returns 0 |
311 | * instead of an error and missing rtsc is set to NULL. |
312 | * |
313 | * See reset_control_bulk_get_exclusive_released() for more information. |
314 | */ |
315 | static inline int __must_check |
316 | reset_control_bulk_get_optional_exclusive_released(struct device *dev, int num_rstcs, |
317 | struct reset_control_bulk_data *rstcs) |
318 | { |
319 | return __reset_control_bulk_get(dev, num_rstcs, rstcs, shared: false, optional: true, acquired: false); |
320 | } |
321 | |
322 | /** |
323 | * reset_control_get_shared - Lookup and obtain a shared reference to a |
324 | * reset controller. |
325 | * @dev: device to be reset by the controller |
326 | * @id: reset line name |
327 | * |
328 | * Returns a struct reset_control or IS_ERR() condition containing errno. |
329 | * This function is intended for use with reset-controls which are shared |
330 | * between hardware blocks. |
331 | * |
332 | * When a reset-control is shared, the behavior of reset_control_assert / |
333 | * deassert is changed, the reset-core will keep track of a deassert_count |
334 | * and only (re-)assert the reset after reset_control_assert has been called |
335 | * as many times as reset_control_deassert was called. Also see the remark |
336 | * about shared reset-controls in the reset_control_assert docs. |
337 | * |
338 | * Calling reset_control_assert without first calling reset_control_deassert |
339 | * is not allowed on a shared reset control. Calling reset_control_reset is |
340 | * also not allowed on a shared reset control. |
341 | * |
342 | * Use of id names is optional. |
343 | */ |
344 | static inline struct reset_control *reset_control_get_shared( |
345 | struct device *dev, const char *id) |
346 | { |
347 | return __reset_control_get(dev, id, index: 0, shared: true, optional: false, acquired: false); |
348 | } |
349 | |
350 | /** |
351 | * reset_control_bulk_get_shared - Lookup and obtain shared references to |
352 | * multiple reset controllers. |
353 | * @dev: device to be reset by the controller |
354 | * @num_rstcs: number of entries in rstcs array |
355 | * @rstcs: array of struct reset_control_bulk_data with reset line names set |
356 | * |
357 | * Fills the rstcs array with pointers to shared reset controls and |
358 | * returns 0, or an IS_ERR() condition containing errno. |
359 | */ |
360 | static inline int __must_check |
361 | reset_control_bulk_get_shared(struct device *dev, int num_rstcs, |
362 | struct reset_control_bulk_data *rstcs) |
363 | { |
364 | return __reset_control_bulk_get(dev, num_rstcs, rstcs, shared: true, optional: false, acquired: false); |
365 | } |
366 | |
367 | /** |
368 | * reset_control_get_optional_exclusive - optional reset_control_get_exclusive() |
369 | * @dev: device to be reset by the controller |
370 | * @id: reset line name |
371 | * |
372 | * Optional variant of reset_control_get_exclusive(). If the requested reset |
373 | * is not specified in the device tree, this function returns NULL instead of |
374 | * an error. |
375 | * |
376 | * See reset_control_get_exclusive() for more information. |
377 | */ |
378 | static inline struct reset_control *reset_control_get_optional_exclusive( |
379 | struct device *dev, const char *id) |
380 | { |
381 | return __reset_control_get(dev, id, index: 0, shared: false, optional: true, acquired: true); |
382 | } |
383 | |
384 | /** |
385 | * reset_control_bulk_get_optional_exclusive - optional |
386 | * reset_control_bulk_get_exclusive() |
387 | * @dev: device to be reset by the controller |
388 | * @num_rstcs: number of entries in rstcs array |
389 | * @rstcs: array of struct reset_control_bulk_data with reset line names set |
390 | * |
391 | * Optional variant of reset_control_bulk_get_exclusive(). If any of the |
392 | * requested resets are not specified in the device tree, this function sets |
393 | * them to NULL instead of returning an error. |
394 | * |
395 | * See reset_control_bulk_get_exclusive() for more information. |
396 | */ |
397 | static inline int __must_check |
398 | reset_control_bulk_get_optional_exclusive(struct device *dev, int num_rstcs, |
399 | struct reset_control_bulk_data *rstcs) |
400 | { |
401 | return __reset_control_bulk_get(dev, num_rstcs, rstcs, shared: false, optional: true, acquired: true); |
402 | } |
403 | |
404 | /** |
405 | * reset_control_get_optional_shared - optional reset_control_get_shared() |
406 | * @dev: device to be reset by the controller |
407 | * @id: reset line name |
408 | * |
409 | * Optional variant of reset_control_get_shared(). If the requested reset |
410 | * is not specified in the device tree, this function returns NULL instead of |
411 | * an error. |
412 | * |
413 | * See reset_control_get_shared() for more information. |
414 | */ |
415 | static inline struct reset_control *reset_control_get_optional_shared( |
416 | struct device *dev, const char *id) |
417 | { |
418 | return __reset_control_get(dev, id, index: 0, shared: true, optional: true, acquired: false); |
419 | } |
420 | |
421 | /** |
422 | * reset_control_bulk_get_optional_shared - optional |
423 | * reset_control_bulk_get_shared() |
424 | * @dev: device to be reset by the controller |
425 | * @num_rstcs: number of entries in rstcs array |
426 | * @rstcs: array of struct reset_control_bulk_data with reset line names set |
427 | * |
428 | * Optional variant of reset_control_bulk_get_shared(). If the requested resets |
429 | * are not specified in the device tree, this function sets them to NULL |
430 | * instead of returning an error. |
431 | * |
432 | * See reset_control_bulk_get_shared() for more information. |
433 | */ |
434 | static inline int __must_check |
435 | reset_control_bulk_get_optional_shared(struct device *dev, int num_rstcs, |
436 | struct reset_control_bulk_data *rstcs) |
437 | { |
438 | return __reset_control_bulk_get(dev, num_rstcs, rstcs, shared: true, optional: true, acquired: false); |
439 | } |
440 | |
441 | /** |
442 | * of_reset_control_get_exclusive - Lookup and obtain an exclusive reference |
443 | * to a reset controller. |
444 | * @node: device to be reset by the controller |
445 | * @id: reset line name |
446 | * |
447 | * Returns a struct reset_control or IS_ERR() condition containing errno. |
448 | * |
449 | * Use of id names is optional. |
450 | */ |
451 | static inline struct reset_control *of_reset_control_get_exclusive( |
452 | struct device_node *node, const char *id) |
453 | { |
454 | return __of_reset_control_get(node, id, index: 0, shared: false, optional: false, acquired: true); |
455 | } |
456 | |
457 | /** |
458 | * of_reset_control_get_optional_exclusive - Lookup and obtain an optional exclusive |
459 | * reference to a reset controller. |
460 | * @node: device to be reset by the controller |
461 | * @id: reset line name |
462 | * |
463 | * Optional variant of of_reset_control_get_exclusive(). If the requested reset |
464 | * is not specified in the device tree, this function returns NULL instead of |
465 | * an error. |
466 | * |
467 | * Returns a struct reset_control or IS_ERR() condition containing errno. |
468 | * |
469 | * Use of id names is optional. |
470 | */ |
471 | static inline struct reset_control *of_reset_control_get_optional_exclusive( |
472 | struct device_node *node, const char *id) |
473 | { |
474 | return __of_reset_control_get(node, id, index: 0, shared: false, optional: true, acquired: true); |
475 | } |
476 | |
477 | /** |
478 | * of_reset_control_get_shared - Lookup and obtain a shared reference |
479 | * to a reset controller. |
480 | * @node: device to be reset by the controller |
481 | * @id: reset line name |
482 | * |
483 | * When a reset-control is shared, the behavior of reset_control_assert / |
484 | * deassert is changed, the reset-core will keep track of a deassert_count |
485 | * and only (re-)assert the reset after reset_control_assert has been called |
486 | * as many times as reset_control_deassert was called. Also see the remark |
487 | * about shared reset-controls in the reset_control_assert docs. |
488 | * |
489 | * Calling reset_control_assert without first calling reset_control_deassert |
490 | * is not allowed on a shared reset control. Calling reset_control_reset is |
491 | * also not allowed on a shared reset control. |
492 | * Returns a struct reset_control or IS_ERR() condition containing errno. |
493 | * |
494 | * Use of id names is optional. |
495 | */ |
496 | static inline struct reset_control *of_reset_control_get_shared( |
497 | struct device_node *node, const char *id) |
498 | { |
499 | return __of_reset_control_get(node, id, index: 0, shared: true, optional: false, acquired: false); |
500 | } |
501 | |
502 | /** |
503 | * of_reset_control_get_exclusive_by_index - Lookup and obtain an exclusive |
504 | * reference to a reset controller |
505 | * by index. |
506 | * @node: device to be reset by the controller |
507 | * @index: index of the reset controller |
508 | * |
509 | * This is to be used to perform a list of resets for a device or power domain |
510 | * in whatever order. Returns a struct reset_control or IS_ERR() condition |
511 | * containing errno. |
512 | */ |
513 | static inline struct reset_control *of_reset_control_get_exclusive_by_index( |
514 | struct device_node *node, int index) |
515 | { |
516 | return __of_reset_control_get(node, NULL, index, shared: false, optional: false, acquired: true); |
517 | } |
518 | |
519 | /** |
520 | * of_reset_control_get_shared_by_index - Lookup and obtain a shared |
521 | * reference to a reset controller |
522 | * by index. |
523 | * @node: device to be reset by the controller |
524 | * @index: index of the reset controller |
525 | * |
526 | * When a reset-control is shared, the behavior of reset_control_assert / |
527 | * deassert is changed, the reset-core will keep track of a deassert_count |
528 | * and only (re-)assert the reset after reset_control_assert has been called |
529 | * as many times as reset_control_deassert was called. Also see the remark |
530 | * about shared reset-controls in the reset_control_assert docs. |
531 | * |
532 | * Calling reset_control_assert without first calling reset_control_deassert |
533 | * is not allowed on a shared reset control. Calling reset_control_reset is |
534 | * also not allowed on a shared reset control. |
535 | * Returns a struct reset_control or IS_ERR() condition containing errno. |
536 | * |
537 | * This is to be used to perform a list of resets for a device or power domain |
538 | * in whatever order. Returns a struct reset_control or IS_ERR() condition |
539 | * containing errno. |
540 | */ |
541 | static inline struct reset_control *of_reset_control_get_shared_by_index( |
542 | struct device_node *node, int index) |
543 | { |
544 | return __of_reset_control_get(node, NULL, index, shared: true, optional: false, acquired: false); |
545 | } |
546 | |
547 | /** |
548 | * devm_reset_control_get_exclusive - resource managed |
549 | * reset_control_get_exclusive() |
550 | * @dev: device to be reset by the controller |
551 | * @id: reset line name |
552 | * |
553 | * Managed reset_control_get_exclusive(). For reset controllers returned |
554 | * from this function, reset_control_put() is called automatically on driver |
555 | * detach. |
556 | * |
557 | * See reset_control_get_exclusive() for more information. |
558 | */ |
559 | static inline struct reset_control * |
560 | __must_check devm_reset_control_get_exclusive(struct device *dev, |
561 | const char *id) |
562 | { |
563 | return __devm_reset_control_get(dev, id, index: 0, shared: false, optional: false, acquired: true); |
564 | } |
565 | |
566 | /** |
567 | * devm_reset_control_bulk_get_exclusive - resource managed |
568 | * reset_control_bulk_get_exclusive() |
569 | * @dev: device to be reset by the controller |
570 | * @num_rstcs: number of entries in rstcs array |
571 | * @rstcs: array of struct reset_control_bulk_data with reset line names set |
572 | * |
573 | * Managed reset_control_bulk_get_exclusive(). For reset controllers returned |
574 | * from this function, reset_control_put() is called automatically on driver |
575 | * detach. |
576 | * |
577 | * See reset_control_bulk_get_exclusive() for more information. |
578 | */ |
579 | static inline int __must_check |
580 | devm_reset_control_bulk_get_exclusive(struct device *dev, int num_rstcs, |
581 | struct reset_control_bulk_data *rstcs) |
582 | { |
583 | return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, shared: false, optional: false, acquired: true); |
584 | } |
585 | |
586 | /** |
587 | * devm_reset_control_get_exclusive_released - resource managed |
588 | * reset_control_get_exclusive_released() |
589 | * @dev: device to be reset by the controller |
590 | * @id: reset line name |
591 | * |
592 | * Managed reset_control_get_exclusive_released(). For reset controllers |
593 | * returned from this function, reset_control_put() is called automatically on |
594 | * driver detach. |
595 | * |
596 | * See reset_control_get_exclusive_released() for more information. |
597 | */ |
598 | static inline struct reset_control * |
599 | __must_check devm_reset_control_get_exclusive_released(struct device *dev, |
600 | const char *id) |
601 | { |
602 | return __devm_reset_control_get(dev, id, index: 0, shared: false, optional: false, acquired: false); |
603 | } |
604 | |
605 | /** |
606 | * devm_reset_control_bulk_get_exclusive_released - resource managed |
607 | * reset_control_bulk_get_exclusive_released() |
608 | * @dev: device to be reset by the controller |
609 | * @num_rstcs: number of entries in rstcs array |
610 | * @rstcs: array of struct reset_control_bulk_data with reset line names set |
611 | * |
612 | * Managed reset_control_bulk_get_exclusive_released(). For reset controllers |
613 | * returned from this function, reset_control_put() is called automatically on |
614 | * driver detach. |
615 | * |
616 | * See reset_control_bulk_get_exclusive_released() for more information. |
617 | */ |
618 | static inline int __must_check |
619 | devm_reset_control_bulk_get_exclusive_released(struct device *dev, int num_rstcs, |
620 | struct reset_control_bulk_data *rstcs) |
621 | { |
622 | return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, shared: false, optional: false, acquired: false); |
623 | } |
624 | |
625 | /** |
626 | * devm_reset_control_get_optional_exclusive_released - resource managed |
627 | * reset_control_get_optional_exclusive_released() |
628 | * @dev: device to be reset by the controller |
629 | * @id: reset line name |
630 | * |
631 | * Managed-and-optional variant of reset_control_get_exclusive_released(). For |
632 | * reset controllers returned from this function, reset_control_put() is called |
633 | * automatically on driver detach. |
634 | * |
635 | * See reset_control_get_exclusive_released() for more information. |
636 | */ |
637 | static inline struct reset_control * |
638 | __must_check devm_reset_control_get_optional_exclusive_released(struct device *dev, |
639 | const char *id) |
640 | { |
641 | return __devm_reset_control_get(dev, id, index: 0, shared: false, optional: true, acquired: false); |
642 | } |
643 | |
644 | /** |
645 | * devm_reset_control_bulk_get_optional_exclusive_released - resource managed |
646 | * reset_control_bulk_optional_get_exclusive_released() |
647 | * @dev: device to be reset by the controller |
648 | * @num_rstcs: number of entries in rstcs array |
649 | * @rstcs: array of struct reset_control_bulk_data with reset line names set |
650 | * |
651 | * Managed reset_control_bulk_optional_get_exclusive_released(). For reset |
652 | * controllers returned from this function, reset_control_put() is called |
653 | * automatically on driver detach. |
654 | * |
655 | * See reset_control_bulk_optional_get_exclusive_released() for more information. |
656 | */ |
657 | static inline int __must_check |
658 | devm_reset_control_bulk_get_optional_exclusive_released(struct device *dev, int num_rstcs, |
659 | struct reset_control_bulk_data *rstcs) |
660 | { |
661 | return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, shared: false, optional: true, acquired: false); |
662 | } |
663 | |
664 | /** |
665 | * devm_reset_control_get_shared - resource managed reset_control_get_shared() |
666 | * @dev: device to be reset by the controller |
667 | * @id: reset line name |
668 | * |
669 | * Managed reset_control_get_shared(). For reset controllers returned from |
670 | * this function, reset_control_put() is called automatically on driver detach. |
671 | * See reset_control_get_shared() for more information. |
672 | */ |
673 | static inline struct reset_control *devm_reset_control_get_shared( |
674 | struct device *dev, const char *id) |
675 | { |
676 | return __devm_reset_control_get(dev, id, index: 0, shared: true, optional: false, acquired: false); |
677 | } |
678 | |
679 | /** |
680 | * devm_reset_control_bulk_get_shared - resource managed |
681 | * reset_control_bulk_get_shared() |
682 | * @dev: device to be reset by the controller |
683 | * @num_rstcs: number of entries in rstcs array |
684 | * @rstcs: array of struct reset_control_bulk_data with reset line names set |
685 | * |
686 | * Managed reset_control_bulk_get_shared(). For reset controllers returned |
687 | * from this function, reset_control_put() is called automatically on driver |
688 | * detach. |
689 | * |
690 | * See reset_control_bulk_get_shared() for more information. |
691 | */ |
692 | static inline int __must_check |
693 | devm_reset_control_bulk_get_shared(struct device *dev, int num_rstcs, |
694 | struct reset_control_bulk_data *rstcs) |
695 | { |
696 | return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, shared: true, optional: false, acquired: false); |
697 | } |
698 | |
699 | /** |
700 | * devm_reset_control_get_optional_exclusive - resource managed |
701 | * reset_control_get_optional_exclusive() |
702 | * @dev: device to be reset by the controller |
703 | * @id: reset line name |
704 | * |
705 | * Managed reset_control_get_optional_exclusive(). For reset controllers |
706 | * returned from this function, reset_control_put() is called automatically on |
707 | * driver detach. |
708 | * |
709 | * See reset_control_get_optional_exclusive() for more information. |
710 | */ |
711 | static inline struct reset_control *devm_reset_control_get_optional_exclusive( |
712 | struct device *dev, const char *id) |
713 | { |
714 | return __devm_reset_control_get(dev, id, index: 0, shared: false, optional: true, acquired: true); |
715 | } |
716 | |
717 | /** |
718 | * devm_reset_control_bulk_get_optional_exclusive - resource managed |
719 | * reset_control_bulk_get_optional_exclusive() |
720 | * @dev: device to be reset by the controller |
721 | * @num_rstcs: number of entries in rstcs array |
722 | * @rstcs: array of struct reset_control_bulk_data with reset line names set |
723 | * |
724 | * Managed reset_control_bulk_get_optional_exclusive(). For reset controllers |
725 | * returned from this function, reset_control_put() is called automatically on |
726 | * driver detach. |
727 | * |
728 | * See reset_control_bulk_get_optional_exclusive() for more information. |
729 | */ |
730 | static inline int __must_check |
731 | devm_reset_control_bulk_get_optional_exclusive(struct device *dev, int num_rstcs, |
732 | struct reset_control_bulk_data *rstcs) |
733 | { |
734 | return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, shared: false, optional: true, acquired: true); |
735 | } |
736 | |
737 | /** |
738 | * devm_reset_control_get_optional_shared - resource managed |
739 | * reset_control_get_optional_shared() |
740 | * @dev: device to be reset by the controller |
741 | * @id: reset line name |
742 | * |
743 | * Managed reset_control_get_optional_shared(). For reset controllers returned |
744 | * from this function, reset_control_put() is called automatically on driver |
745 | * detach. |
746 | * |
747 | * See reset_control_get_optional_shared() for more information. |
748 | */ |
749 | static inline struct reset_control *devm_reset_control_get_optional_shared( |
750 | struct device *dev, const char *id) |
751 | { |
752 | return __devm_reset_control_get(dev, id, index: 0, shared: true, optional: true, acquired: false); |
753 | } |
754 | |
755 | /** |
756 | * devm_reset_control_bulk_get_optional_shared - resource managed |
757 | * reset_control_bulk_get_optional_shared() |
758 | * @dev: device to be reset by the controller |
759 | * @num_rstcs: number of entries in rstcs array |
760 | * @rstcs: array of struct reset_control_bulk_data with reset line names set |
761 | * |
762 | * Managed reset_control_bulk_get_optional_shared(). For reset controllers |
763 | * returned from this function, reset_control_put() is called automatically on |
764 | * driver detach. |
765 | * |
766 | * See reset_control_bulk_get_optional_shared() for more information. |
767 | */ |
768 | static inline int __must_check |
769 | devm_reset_control_bulk_get_optional_shared(struct device *dev, int num_rstcs, |
770 | struct reset_control_bulk_data *rstcs) |
771 | { |
772 | return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, shared: true, optional: true, acquired: false); |
773 | } |
774 | |
775 | /** |
776 | * devm_reset_control_get_exclusive_by_index - resource managed |
777 | * reset_control_get_exclusive() |
778 | * @dev: device to be reset by the controller |
779 | * @index: index of the reset controller |
780 | * |
781 | * Managed reset_control_get_exclusive(). For reset controllers returned from |
782 | * this function, reset_control_put() is called automatically on driver |
783 | * detach. |
784 | * |
785 | * See reset_control_get_exclusive() for more information. |
786 | */ |
787 | static inline struct reset_control * |
788 | devm_reset_control_get_exclusive_by_index(struct device *dev, int index) |
789 | { |
790 | return __devm_reset_control_get(dev, NULL, index, shared: false, optional: false, acquired: true); |
791 | } |
792 | |
793 | /** |
794 | * devm_reset_control_get_shared_by_index - resource managed |
795 | * reset_control_get_shared |
796 | * @dev: device to be reset by the controller |
797 | * @index: index of the reset controller |
798 | * |
799 | * Managed reset_control_get_shared(). For reset controllers returned from |
800 | * this function, reset_control_put() is called automatically on driver detach. |
801 | * See reset_control_get_shared() for more information. |
802 | */ |
803 | static inline struct reset_control * |
804 | devm_reset_control_get_shared_by_index(struct device *dev, int index) |
805 | { |
806 | return __devm_reset_control_get(dev, NULL, index, shared: true, optional: false, acquired: false); |
807 | } |
808 | |
809 | /* |
810 | * TEMPORARY calls to use during transition: |
811 | * |
812 | * of_reset_control_get() => of_reset_control_get_exclusive() |
813 | * |
814 | * These inline function calls will be removed once all consumers |
815 | * have been moved over to the new explicit API. |
816 | */ |
817 | static inline struct reset_control *of_reset_control_get( |
818 | struct device_node *node, const char *id) |
819 | { |
820 | return of_reset_control_get_exclusive(node, id); |
821 | } |
822 | |
823 | static inline struct reset_control *of_reset_control_get_by_index( |
824 | struct device_node *node, int index) |
825 | { |
826 | return of_reset_control_get_exclusive_by_index(node, index); |
827 | } |
828 | |
829 | static inline struct reset_control *devm_reset_control_get( |
830 | struct device *dev, const char *id) |
831 | { |
832 | return devm_reset_control_get_exclusive(dev, id); |
833 | } |
834 | |
835 | static inline struct reset_control *devm_reset_control_get_optional( |
836 | struct device *dev, const char *id) |
837 | { |
838 | return devm_reset_control_get_optional_exclusive(dev, id); |
839 | |
840 | } |
841 | |
842 | static inline struct reset_control *devm_reset_control_get_by_index( |
843 | struct device *dev, int index) |
844 | { |
845 | return devm_reset_control_get_exclusive_by_index(dev, index); |
846 | } |
847 | |
848 | /* |
849 | * APIs to manage a list of reset controllers |
850 | */ |
851 | static inline struct reset_control * |
852 | devm_reset_control_array_get_exclusive(struct device *dev) |
853 | { |
854 | return devm_reset_control_array_get(dev, shared: false, optional: false); |
855 | } |
856 | |
857 | static inline struct reset_control * |
858 | devm_reset_control_array_get_shared(struct device *dev) |
859 | { |
860 | return devm_reset_control_array_get(dev, shared: true, optional: false); |
861 | } |
862 | |
863 | static inline struct reset_control * |
864 | devm_reset_control_array_get_optional_exclusive(struct device *dev) |
865 | { |
866 | return devm_reset_control_array_get(dev, shared: false, optional: true); |
867 | } |
868 | |
869 | static inline struct reset_control * |
870 | devm_reset_control_array_get_optional_shared(struct device *dev) |
871 | { |
872 | return devm_reset_control_array_get(dev, shared: true, optional: true); |
873 | } |
874 | |
875 | static inline struct reset_control * |
876 | of_reset_control_array_get_exclusive(struct device_node *node) |
877 | { |
878 | return of_reset_control_array_get(np: node, shared: false, optional: false, acquired: true); |
879 | } |
880 | |
881 | static inline struct reset_control * |
882 | of_reset_control_array_get_exclusive_released(struct device_node *node) |
883 | { |
884 | return of_reset_control_array_get(np: node, shared: false, optional: false, acquired: false); |
885 | } |
886 | |
887 | static inline struct reset_control * |
888 | of_reset_control_array_get_shared(struct device_node *node) |
889 | { |
890 | return of_reset_control_array_get(np: node, shared: true, optional: false, acquired: true); |
891 | } |
892 | |
893 | static inline struct reset_control * |
894 | of_reset_control_array_get_optional_exclusive(struct device_node *node) |
895 | { |
896 | return of_reset_control_array_get(np: node, shared: false, optional: true, acquired: true); |
897 | } |
898 | |
899 | static inline struct reset_control * |
900 | of_reset_control_array_get_optional_shared(struct device_node *node) |
901 | { |
902 | return of_reset_control_array_get(np: node, shared: true, optional: true, acquired: true); |
903 | } |
904 | #endif |
905 | |