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 
reset_control_reset(struct reset_control * rstc)74 static inline int reset_control_reset(struct reset_control *rstc)
75 {
76 	return 0;
77 }
78 
reset_control_rearm(struct reset_control * rstc)79 static inline int reset_control_rearm(struct reset_control *rstc)
80 {
81 	return 0;
82 }
83 
reset_control_assert(struct reset_control * rstc)84 static inline int reset_control_assert(struct reset_control *rstc)
85 {
86 	return 0;
87 }
88 
reset_control_deassert(struct reset_control * rstc)89 static inline int reset_control_deassert(struct reset_control *rstc)
90 {
91 	return 0;
92 }
93 
reset_control_status(struct reset_control * rstc)94 static inline int reset_control_status(struct reset_control *rstc)
95 {
96 	return 0;
97 }
98 
reset_control_acquire(struct reset_control * rstc)99 static inline int reset_control_acquire(struct reset_control *rstc)
100 {
101 	return 0;
102 }
103 
reset_control_release(struct reset_control * rstc)104 static inline void reset_control_release(struct reset_control *rstc)
105 {
106 }
107 
reset_control_put(struct reset_control * rstc)108 static inline void reset_control_put(struct reset_control *rstc)
109 {
110 }
111 
__device_reset(struct device * dev,bool optional)112 static inline int __device_reset(struct device *dev, bool optional)
113 {
114 	return optional ? 0 : -ENOTSUPP;
115 }
116 
__of_reset_control_get(struct device_node * node,const char * id,int index,bool shared,bool optional,bool acquired)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 
__reset_control_get(struct device * dev,const char * id,int index,bool shared,bool optional,bool acquired)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
reset_control_bulk_reset(int num_rstcs,struct reset_control_bulk_data * rstcs)134 reset_control_bulk_reset(int num_rstcs, struct reset_control_bulk_data *rstcs)
135 {
136 	return 0;
137 }
138 
139 static inline int
reset_control_bulk_assert(int num_rstcs,struct reset_control_bulk_data * rstcs)140 reset_control_bulk_assert(int num_rstcs, struct reset_control_bulk_data *rstcs)
141 {
142 	return 0;
143 }
144 
145 static inline int
reset_control_bulk_deassert(int num_rstcs,struct reset_control_bulk_data * rstcs)146 reset_control_bulk_deassert(int num_rstcs, struct reset_control_bulk_data *rstcs)
147 {
148 	return 0;
149 }
150 
151 static inline int
reset_control_bulk_acquire(int num_rstcs,struct reset_control_bulk_data * rstcs)152 reset_control_bulk_acquire(int num_rstcs, struct reset_control_bulk_data *rstcs)
153 {
154 	return 0;
155 }
156 
157 static inline void
reset_control_bulk_release(int num_rstcs,struct reset_control_bulk_data * rstcs)158 reset_control_bulk_release(int num_rstcs, struct reset_control_bulk_data *rstcs)
159 {
160 }
161 
162 static inline int
__reset_control_bulk_get(struct device * dev,int num_rstcs,struct reset_control_bulk_data * rstcs,bool shared,bool optional,bool acquired)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
reset_control_bulk_put(int num_rstcs,struct reset_control_bulk_data * rstcs)171 reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs)
172 {
173 }
174 
__devm_reset_control_get(struct device * dev,const char * id,int index,bool shared,bool optional,bool acquired)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
__devm_reset_control_bulk_get(struct device * dev,int num_rstcs,struct reset_control_bulk_data * rstcs,bool shared,bool optional,bool acquired)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 *
devm_reset_control_array_get(struct device * dev,bool shared,bool optional)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 *
of_reset_control_array_get(struct device_node * np,bool shared,bool optional,bool acquired)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 
reset_control_get_count(struct device * dev)204 static inline int reset_control_get_count(struct device *dev)
205 {
206 	return -ENOENT;
207 }
208 
209 #endif /* CONFIG_RESET_CONTROLLER */
210 
device_reset(struct device * dev)211 static inline int __must_check device_reset(struct device *dev)
212 {
213 	return __device_reset(dev, false);
214 }
215 
device_reset_optional(struct device * dev)216 static inline int device_reset_optional(struct device *dev)
217 {
218 	return __device_reset(dev, 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 *
reset_control_get_exclusive(struct device * dev,const char * id)237 __must_check reset_control_get_exclusive(struct device *dev, const char *id)
238 {
239 	return __reset_control_get(dev, id, 0, false, false, 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
reset_control_bulk_get_exclusive(struct device * dev,int num_rstcs,struct reset_control_bulk_data * rstcs)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, false, false, 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 *
reset_control_get_exclusive_released(struct device * dev,const char * id)274 __must_check reset_control_get_exclusive_released(struct device *dev,
275 						  const char *id)
276 {
277 	return __reset_control_get(dev, id, 0, false, false, 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
reset_control_bulk_get_exclusive_released(struct device * dev,int num_rstcs,struct reset_control_bulk_data * rstcs)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, false, false, 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
reset_control_bulk_get_optional_exclusive_released(struct device * dev,int num_rstcs,struct reset_control_bulk_data * rstcs)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, false, true, 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  */
reset_control_get_shared(struct device * dev,const char * id)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, 0, true, false, 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
reset_control_bulk_get_shared(struct device * dev,int num_rstcs,struct reset_control_bulk_data * rstcs)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, true, false, 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  */
reset_control_get_optional_exclusive(struct device * dev,const char * id)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, 0, false, true, 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
reset_control_bulk_get_optional_exclusive(struct device * dev,int num_rstcs,struct reset_control_bulk_data * rstcs)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, false, true, 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  */
reset_control_get_optional_shared(struct device * dev,const char * id)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, 0, true, true, 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
reset_control_bulk_get_optional_shared(struct device * dev,int num_rstcs,struct reset_control_bulk_data * rstcs)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, true, true, 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  */
of_reset_control_get_exclusive(struct device_node * node,const char * id)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, 0, false, false, 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  */
of_reset_control_get_optional_exclusive(struct device_node * node,const char * id)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, 0, false, true, 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  */
of_reset_control_get_shared(struct device_node * node,const char * id)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, 0, true, false, 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  */
of_reset_control_get_exclusive_by_index(struct device_node * node,int index)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, false, false, 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  */
of_reset_control_get_shared_by_index(struct device_node * node,int index)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, true, false, 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 *
devm_reset_control_get_exclusive(struct device * dev,const char * id)560 __must_check devm_reset_control_get_exclusive(struct device *dev,
561 					      const char *id)
562 {
563 	return __devm_reset_control_get(dev, id, 0, false, false, 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
devm_reset_control_bulk_get_exclusive(struct device * dev,int num_rstcs,struct reset_control_bulk_data * rstcs)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, false, false, 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 *
devm_reset_control_get_exclusive_released(struct device * dev,const char * id)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, 0, false, false, 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
devm_reset_control_bulk_get_exclusive_released(struct device * dev,int num_rstcs,struct reset_control_bulk_data * rstcs)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, false, false, 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 *
devm_reset_control_get_optional_exclusive_released(struct device * dev,const char * id)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, 0, false, true, 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
devm_reset_control_bulk_get_optional_exclusive_released(struct device * dev,int num_rstcs,struct reset_control_bulk_data * rstcs)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, false, true, 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  */
devm_reset_control_get_shared(struct device * dev,const char * id)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, 0, true, false, 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
devm_reset_control_bulk_get_shared(struct device * dev,int num_rstcs,struct reset_control_bulk_data * rstcs)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, true, false, 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  */
devm_reset_control_get_optional_exclusive(struct device * dev,const char * id)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, 0, false, true, 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
devm_reset_control_bulk_get_optional_exclusive(struct device * dev,int num_rstcs,struct reset_control_bulk_data * rstcs)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, false, true, 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  */
devm_reset_control_get_optional_shared(struct device * dev,const char * id)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, 0, true, true, 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
devm_reset_control_bulk_get_optional_shared(struct device * dev,int num_rstcs,struct reset_control_bulk_data * rstcs)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, true, true, 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 *
devm_reset_control_get_exclusive_by_index(struct device * dev,int index)788 devm_reset_control_get_exclusive_by_index(struct device *dev, int index)
789 {
790 	return __devm_reset_control_get(dev, NULL, index, false, false, 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 *
devm_reset_control_get_shared_by_index(struct device * dev,int index)804 devm_reset_control_get_shared_by_index(struct device *dev, int index)
805 {
806 	return __devm_reset_control_get(dev, NULL, index, true, false, 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  */
of_reset_control_get(struct device_node * node,const char * id)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 
of_reset_control_get_by_index(struct device_node * node,int index)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 
devm_reset_control_get(struct device * dev,const char * id)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 
devm_reset_control_get_optional(struct device * dev,const char * id)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 
devm_reset_control_get_by_index(struct device * dev,int index)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 *
devm_reset_control_array_get_exclusive(struct device * dev)852 devm_reset_control_array_get_exclusive(struct device *dev)
853 {
854 	return devm_reset_control_array_get(dev, false, false);
855 }
856 
857 static inline struct reset_control *
devm_reset_control_array_get_shared(struct device * dev)858 devm_reset_control_array_get_shared(struct device *dev)
859 {
860 	return devm_reset_control_array_get(dev, true, false);
861 }
862 
863 static inline struct reset_control *
devm_reset_control_array_get_optional_exclusive(struct device * dev)864 devm_reset_control_array_get_optional_exclusive(struct device *dev)
865 {
866 	return devm_reset_control_array_get(dev, false, true);
867 }
868 
869 static inline struct reset_control *
devm_reset_control_array_get_optional_shared(struct device * dev)870 devm_reset_control_array_get_optional_shared(struct device *dev)
871 {
872 	return devm_reset_control_array_get(dev, true, true);
873 }
874 
875 static inline struct reset_control *
of_reset_control_array_get_exclusive(struct device_node * node)876 of_reset_control_array_get_exclusive(struct device_node *node)
877 {
878 	return of_reset_control_array_get(node, false, false, true);
879 }
880 
881 static inline struct reset_control *
of_reset_control_array_get_exclusive_released(struct device_node * node)882 of_reset_control_array_get_exclusive_released(struct device_node *node)
883 {
884 	return of_reset_control_array_get(node, false, false, false);
885 }
886 
887 static inline struct reset_control *
of_reset_control_array_get_shared(struct device_node * node)888 of_reset_control_array_get_shared(struct device_node *node)
889 {
890 	return of_reset_control_array_get(node, true, false, true);
891 }
892 
893 static inline struct reset_control *
of_reset_control_array_get_optional_exclusive(struct device_node * node)894 of_reset_control_array_get_optional_exclusive(struct device_node *node)
895 {
896 	return of_reset_control_array_get(node, false, true, true);
897 }
898 
899 static inline struct reset_control *
of_reset_control_array_get_optional_shared(struct device_node * node)900 of_reset_control_array_get_optional_shared(struct device_node *node)
901 {
902 	return of_reset_control_array_get(node, true, true, true);
903 }
904 #endif
905