Merge tag 'fixes-v5.13' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris...
[linux-2.6-microblaze.git] / drivers / reset / core.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Reset Controller framework
4  *
5  * Copyright 2013 Philipp Zabel, Pengutronix
6  */
7 #include <linux/atomic.h>
8 #include <linux/device.h>
9 #include <linux/err.h>
10 #include <linux/export.h>
11 #include <linux/kernel.h>
12 #include <linux/kref.h>
13 #include <linux/module.h>
14 #include <linux/of.h>
15 #include <linux/reset.h>
16 #include <linux/reset-controller.h>
17 #include <linux/slab.h>
18
19 static DEFINE_MUTEX(reset_list_mutex);
20 static LIST_HEAD(reset_controller_list);
21
22 static DEFINE_MUTEX(reset_lookup_mutex);
23 static LIST_HEAD(reset_lookup_list);
24
25 /**
26  * struct reset_control - a reset control
27  * @rcdev: a pointer to the reset controller device
28  *         this reset control belongs to
29  * @list: list entry for the rcdev's reset controller list
30  * @id: ID of the reset controller in the reset
31  *      controller device
32  * @refcnt: Number of gets of this reset_control
33  * @acquired: Only one reset_control may be acquired for a given rcdev and id.
34  * @shared: Is this a shared (1), or an exclusive (0) reset_control?
35  * @array: Is this an array of reset controls (1)?
36  * @deassert_count: Number of times this reset line has been deasserted
37  * @triggered_count: Number of times this reset line has been reset. Currently
38  *                   only used for shared resets, which means that the value
39  *                   will be either 0 or 1.
40  */
41 struct reset_control {
42         struct reset_controller_dev *rcdev;
43         struct list_head list;
44         unsigned int id;
45         struct kref refcnt;
46         bool acquired;
47         bool shared;
48         bool array;
49         atomic_t deassert_count;
50         atomic_t triggered_count;
51 };
52
53 /**
54  * struct reset_control_array - an array of reset controls
55  * @base: reset control for compatibility with reset control API functions
56  * @num_rstcs: number of reset controls
57  * @rstc: array of reset controls
58  */
59 struct reset_control_array {
60         struct reset_control base;
61         unsigned int num_rstcs;
62         struct reset_control *rstc[];
63 };
64
65 static const char *rcdev_name(struct reset_controller_dev *rcdev)
66 {
67         if (rcdev->dev)
68                 return dev_name(rcdev->dev);
69
70         if (rcdev->of_node)
71                 return rcdev->of_node->full_name;
72
73         return NULL;
74 }
75
76 /**
77  * of_reset_simple_xlate - translate reset_spec to the reset line number
78  * @rcdev: a pointer to the reset controller device
79  * @reset_spec: reset line specifier as found in the device tree
80  *
81  * This static translation function is used by default if of_xlate in
82  * :c:type:`reset_controller_dev` is not set. It is useful for all reset
83  * controllers with 1:1 mapping, where reset lines can be indexed by number
84  * without gaps.
85  */
86 static int of_reset_simple_xlate(struct reset_controller_dev *rcdev,
87                           const struct of_phandle_args *reset_spec)
88 {
89         if (reset_spec->args[0] >= rcdev->nr_resets)
90                 return -EINVAL;
91
92         return reset_spec->args[0];
93 }
94
95 /**
96  * reset_controller_register - register a reset controller device
97  * @rcdev: a pointer to the initialized reset controller device
98  */
99 int reset_controller_register(struct reset_controller_dev *rcdev)
100 {
101         if (!rcdev->of_xlate) {
102                 rcdev->of_reset_n_cells = 1;
103                 rcdev->of_xlate = of_reset_simple_xlate;
104         }
105
106         INIT_LIST_HEAD(&rcdev->reset_control_head);
107
108         mutex_lock(&reset_list_mutex);
109         list_add(&rcdev->list, &reset_controller_list);
110         mutex_unlock(&reset_list_mutex);
111
112         return 0;
113 }
114 EXPORT_SYMBOL_GPL(reset_controller_register);
115
116 /**
117  * reset_controller_unregister - unregister a reset controller device
118  * @rcdev: a pointer to the reset controller device
119  */
120 void reset_controller_unregister(struct reset_controller_dev *rcdev)
121 {
122         mutex_lock(&reset_list_mutex);
123         list_del(&rcdev->list);
124         mutex_unlock(&reset_list_mutex);
125 }
126 EXPORT_SYMBOL_GPL(reset_controller_unregister);
127
128 static void devm_reset_controller_release(struct device *dev, void *res)
129 {
130         reset_controller_unregister(*(struct reset_controller_dev **)res);
131 }
132
133 /**
134  * devm_reset_controller_register - resource managed reset_controller_register()
135  * @dev: device that is registering this reset controller
136  * @rcdev: a pointer to the initialized reset controller device
137  *
138  * Managed reset_controller_register(). For reset controllers registered by
139  * this function, reset_controller_unregister() is automatically called on
140  * driver detach. See reset_controller_register() for more information.
141  */
142 int devm_reset_controller_register(struct device *dev,
143                                    struct reset_controller_dev *rcdev)
144 {
145         struct reset_controller_dev **rcdevp;
146         int ret;
147
148         rcdevp = devres_alloc(devm_reset_controller_release, sizeof(*rcdevp),
149                               GFP_KERNEL);
150         if (!rcdevp)
151                 return -ENOMEM;
152
153         ret = reset_controller_register(rcdev);
154         if (ret) {
155                 devres_free(rcdevp);
156                 return ret;
157         }
158
159         *rcdevp = rcdev;
160         devres_add(dev, rcdevp);
161
162         return ret;
163 }
164 EXPORT_SYMBOL_GPL(devm_reset_controller_register);
165
166 /**
167  * reset_controller_add_lookup - register a set of lookup entries
168  * @lookup: array of reset lookup entries
169  * @num_entries: number of entries in the lookup array
170  */
171 void reset_controller_add_lookup(struct reset_control_lookup *lookup,
172                                  unsigned int num_entries)
173 {
174         struct reset_control_lookup *entry;
175         unsigned int i;
176
177         mutex_lock(&reset_lookup_mutex);
178         for (i = 0; i < num_entries; i++) {
179                 entry = &lookup[i];
180
181                 if (!entry->dev_id || !entry->provider) {
182                         pr_warn("%s(): reset lookup entry badly specified, skipping\n",
183                                 __func__);
184                         continue;
185                 }
186
187                 list_add_tail(&entry->list, &reset_lookup_list);
188         }
189         mutex_unlock(&reset_lookup_mutex);
190 }
191 EXPORT_SYMBOL_GPL(reset_controller_add_lookup);
192
193 static inline struct reset_control_array *
194 rstc_to_array(struct reset_control *rstc) {
195         return container_of(rstc, struct reset_control_array, base);
196 }
197
198 static int reset_control_array_reset(struct reset_control_array *resets)
199 {
200         int ret, i;
201
202         for (i = 0; i < resets->num_rstcs; i++) {
203                 ret = reset_control_reset(resets->rstc[i]);
204                 if (ret)
205                         return ret;
206         }
207
208         return 0;
209 }
210
211 static int reset_control_array_rearm(struct reset_control_array *resets)
212 {
213         struct reset_control *rstc;
214         int i;
215
216         for (i = 0; i < resets->num_rstcs; i++) {
217                 rstc = resets->rstc[i];
218
219                 if (!rstc)
220                         continue;
221
222                 if (WARN_ON(IS_ERR(rstc)))
223                         return -EINVAL;
224
225                 if (rstc->shared) {
226                         if (WARN_ON(atomic_read(&rstc->deassert_count) != 0))
227                                 return -EINVAL;
228                 } else {
229                         if (!rstc->acquired)
230                                 return -EPERM;
231                 }
232         }
233
234         for (i = 0; i < resets->num_rstcs; i++) {
235                 rstc = resets->rstc[i];
236
237                 if (rstc && rstc->shared)
238                         WARN_ON(atomic_dec_return(&rstc->triggered_count) < 0);
239         }
240
241         return 0;
242 }
243
244 static int reset_control_array_assert(struct reset_control_array *resets)
245 {
246         int ret, i;
247
248         for (i = 0; i < resets->num_rstcs; i++) {
249                 ret = reset_control_assert(resets->rstc[i]);
250                 if (ret)
251                         goto err;
252         }
253
254         return 0;
255
256 err:
257         while (i--)
258                 reset_control_deassert(resets->rstc[i]);
259         return ret;
260 }
261
262 static int reset_control_array_deassert(struct reset_control_array *resets)
263 {
264         int ret, i;
265
266         for (i = 0; i < resets->num_rstcs; i++) {
267                 ret = reset_control_deassert(resets->rstc[i]);
268                 if (ret)
269                         goto err;
270         }
271
272         return 0;
273
274 err:
275         while (i--)
276                 reset_control_assert(resets->rstc[i]);
277         return ret;
278 }
279
280 static int reset_control_array_acquire(struct reset_control_array *resets)
281 {
282         unsigned int i;
283         int err;
284
285         for (i = 0; i < resets->num_rstcs; i++) {
286                 err = reset_control_acquire(resets->rstc[i]);
287                 if (err < 0)
288                         goto release;
289         }
290
291         return 0;
292
293 release:
294         while (i--)
295                 reset_control_release(resets->rstc[i]);
296
297         return err;
298 }
299
300 static void reset_control_array_release(struct reset_control_array *resets)
301 {
302         unsigned int i;
303
304         for (i = 0; i < resets->num_rstcs; i++)
305                 reset_control_release(resets->rstc[i]);
306 }
307
308 static inline bool reset_control_is_array(struct reset_control *rstc)
309 {
310         return rstc->array;
311 }
312
313 /**
314  * reset_control_reset - reset the controlled device
315  * @rstc: reset controller
316  *
317  * On a shared reset line the actual reset pulse is only triggered once for the
318  * lifetime of the reset_control instance: for all but the first caller this is
319  * a no-op.
320  * Consumers must not use reset_control_(de)assert on shared reset lines when
321  * reset_control_reset has been used.
322  *
323  * If rstc is NULL it is an optional reset and the function will just
324  * return 0.
325  */
326 int reset_control_reset(struct reset_control *rstc)
327 {
328         int ret;
329
330         if (!rstc)
331                 return 0;
332
333         if (WARN_ON(IS_ERR(rstc)))
334                 return -EINVAL;
335
336         if (reset_control_is_array(rstc))
337                 return reset_control_array_reset(rstc_to_array(rstc));
338
339         if (!rstc->rcdev->ops->reset)
340                 return -ENOTSUPP;
341
342         if (rstc->shared) {
343                 if (WARN_ON(atomic_read(&rstc->deassert_count) != 0))
344                         return -EINVAL;
345
346                 if (atomic_inc_return(&rstc->triggered_count) != 1)
347                         return 0;
348         } else {
349                 if (!rstc->acquired)
350                         return -EPERM;
351         }
352
353         ret = rstc->rcdev->ops->reset(rstc->rcdev, rstc->id);
354         if (rstc->shared && ret)
355                 atomic_dec(&rstc->triggered_count);
356
357         return ret;
358 }
359 EXPORT_SYMBOL_GPL(reset_control_reset);
360
361 /**
362  * reset_control_rearm - allow shared reset line to be re-triggered"
363  * @rstc: reset controller
364  *
365  * On a shared reset line the actual reset pulse is only triggered once for the
366  * lifetime of the reset_control instance, except if this call is used.
367  *
368  * Calls to this function must be balanced with calls to reset_control_reset,
369  * a warning is thrown in case triggered_count ever dips below 0.
370  *
371  * Consumers must not use reset_control_(de)assert on shared reset lines when
372  * reset_control_reset or reset_control_rearm have been used.
373  *
374  * If rstc is NULL the function will just return 0.
375  */
376 int reset_control_rearm(struct reset_control *rstc)
377 {
378         if (!rstc)
379                 return 0;
380
381         if (WARN_ON(IS_ERR(rstc)))
382                 return -EINVAL;
383
384         if (reset_control_is_array(rstc))
385                 return reset_control_array_rearm(rstc_to_array(rstc));
386
387         if (rstc->shared) {
388                 if (WARN_ON(atomic_read(&rstc->deassert_count) != 0))
389                         return -EINVAL;
390
391                 WARN_ON(atomic_dec_return(&rstc->triggered_count) < 0);
392         } else {
393                 if (!rstc->acquired)
394                         return -EPERM;
395         }
396
397         return 0;
398 }
399 EXPORT_SYMBOL_GPL(reset_control_rearm);
400
401 /**
402  * reset_control_assert - asserts the reset line
403  * @rstc: reset controller
404  *
405  * Calling this on an exclusive reset controller guarantees that the reset
406  * will be asserted. When called on a shared reset controller the line may
407  * still be deasserted, as long as other users keep it so.
408  *
409  * For shared reset controls a driver cannot expect the hw's registers and
410  * internal state to be reset, but must be prepared for this to happen.
411  * Consumers must not use reset_control_reset on shared reset lines when
412  * reset_control_(de)assert has been used.
413  *
414  * If rstc is NULL it is an optional reset and the function will just
415  * return 0.
416  */
417 int reset_control_assert(struct reset_control *rstc)
418 {
419         if (!rstc)
420                 return 0;
421
422         if (WARN_ON(IS_ERR(rstc)))
423                 return -EINVAL;
424
425         if (reset_control_is_array(rstc))
426                 return reset_control_array_assert(rstc_to_array(rstc));
427
428         if (rstc->shared) {
429                 if (WARN_ON(atomic_read(&rstc->triggered_count) != 0))
430                         return -EINVAL;
431
432                 if (WARN_ON(atomic_read(&rstc->deassert_count) == 0))
433                         return -EINVAL;
434
435                 if (atomic_dec_return(&rstc->deassert_count) != 0)
436                         return 0;
437
438                 /*
439                  * Shared reset controls allow the reset line to be in any state
440                  * after this call, so doing nothing is a valid option.
441                  */
442                 if (!rstc->rcdev->ops->assert)
443                         return 0;
444         } else {
445                 /*
446                  * If the reset controller does not implement .assert(), there
447                  * is no way to guarantee that the reset line is asserted after
448                  * this call.
449                  */
450                 if (!rstc->rcdev->ops->assert)
451                         return -ENOTSUPP;
452
453                 if (!rstc->acquired) {
454                         WARN(1, "reset %s (ID: %u) is not acquired\n",
455                              rcdev_name(rstc->rcdev), rstc->id);
456                         return -EPERM;
457                 }
458         }
459
460         return rstc->rcdev->ops->assert(rstc->rcdev, rstc->id);
461 }
462 EXPORT_SYMBOL_GPL(reset_control_assert);
463
464 /**
465  * reset_control_deassert - deasserts the reset line
466  * @rstc: reset controller
467  *
468  * After calling this function, the reset is guaranteed to be deasserted.
469  * Consumers must not use reset_control_reset on shared reset lines when
470  * reset_control_(de)assert has been used.
471  *
472  * If rstc is NULL it is an optional reset and the function will just
473  * return 0.
474  */
475 int reset_control_deassert(struct reset_control *rstc)
476 {
477         if (!rstc)
478                 return 0;
479
480         if (WARN_ON(IS_ERR(rstc)))
481                 return -EINVAL;
482
483         if (reset_control_is_array(rstc))
484                 return reset_control_array_deassert(rstc_to_array(rstc));
485
486         if (rstc->shared) {
487                 if (WARN_ON(atomic_read(&rstc->triggered_count) != 0))
488                         return -EINVAL;
489
490                 if (atomic_inc_return(&rstc->deassert_count) != 1)
491                         return 0;
492         } else {
493                 if (!rstc->acquired) {
494                         WARN(1, "reset %s (ID: %u) is not acquired\n",
495                              rcdev_name(rstc->rcdev), rstc->id);
496                         return -EPERM;
497                 }
498         }
499
500         /*
501          * If the reset controller does not implement .deassert(), we assume
502          * that it handles self-deasserting reset lines via .reset(). In that
503          * case, the reset lines are deasserted by default. If that is not the
504          * case, the reset controller driver should implement .deassert() and
505          * return -ENOTSUPP.
506          */
507         if (!rstc->rcdev->ops->deassert)
508                 return 0;
509
510         return rstc->rcdev->ops->deassert(rstc->rcdev, rstc->id);
511 }
512 EXPORT_SYMBOL_GPL(reset_control_deassert);
513
514 /**
515  * reset_control_status - returns a negative errno if not supported, a
516  * positive value if the reset line is asserted, or zero if the reset
517  * line is not asserted or if the desc is NULL (optional reset).
518  * @rstc: reset controller
519  */
520 int reset_control_status(struct reset_control *rstc)
521 {
522         if (!rstc)
523                 return 0;
524
525         if (WARN_ON(IS_ERR(rstc)) || reset_control_is_array(rstc))
526                 return -EINVAL;
527
528         if (rstc->rcdev->ops->status)
529                 return rstc->rcdev->ops->status(rstc->rcdev, rstc->id);
530
531         return -ENOTSUPP;
532 }
533 EXPORT_SYMBOL_GPL(reset_control_status);
534
535 /**
536  * reset_control_acquire() - acquires a reset control for exclusive use
537  * @rstc: reset control
538  *
539  * This is used to explicitly acquire a reset control for exclusive use. Note
540  * that exclusive resets are requested as acquired by default. In order for a
541  * second consumer to be able to control the reset, the first consumer has to
542  * release it first. Typically the easiest way to achieve this is to call the
543  * reset_control_get_exclusive_released() to obtain an instance of the reset
544  * control. Such reset controls are not acquired by default.
545  *
546  * Consumers implementing shared access to an exclusive reset need to follow
547  * a specific protocol in order to work together. Before consumers can change
548  * a reset they must acquire exclusive access using reset_control_acquire().
549  * After they are done operating the reset, they must release exclusive access
550  * with a call to reset_control_release(). Consumers are not granted exclusive
551  * access to the reset as long as another consumer hasn't released a reset.
552  *
553  * See also: reset_control_release()
554  */
555 int reset_control_acquire(struct reset_control *rstc)
556 {
557         struct reset_control *rc;
558
559         if (!rstc)
560                 return 0;
561
562         if (WARN_ON(IS_ERR(rstc)))
563                 return -EINVAL;
564
565         if (reset_control_is_array(rstc))
566                 return reset_control_array_acquire(rstc_to_array(rstc));
567
568         mutex_lock(&reset_list_mutex);
569
570         if (rstc->acquired) {
571                 mutex_unlock(&reset_list_mutex);
572                 return 0;
573         }
574
575         list_for_each_entry(rc, &rstc->rcdev->reset_control_head, list) {
576                 if (rstc != rc && rstc->id == rc->id) {
577                         if (rc->acquired) {
578                                 mutex_unlock(&reset_list_mutex);
579                                 return -EBUSY;
580                         }
581                 }
582         }
583
584         rstc->acquired = true;
585
586         mutex_unlock(&reset_list_mutex);
587         return 0;
588 }
589 EXPORT_SYMBOL_GPL(reset_control_acquire);
590
591 /**
592  * reset_control_release() - releases exclusive access to a reset control
593  * @rstc: reset control
594  *
595  * Releases exclusive access right to a reset control previously obtained by a
596  * call to reset_control_acquire(). Until a consumer calls this function, no
597  * other consumers will be granted exclusive access.
598  *
599  * See also: reset_control_acquire()
600  */
601 void reset_control_release(struct reset_control *rstc)
602 {
603         if (!rstc || WARN_ON(IS_ERR(rstc)))
604                 return;
605
606         if (reset_control_is_array(rstc))
607                 reset_control_array_release(rstc_to_array(rstc));
608         else
609                 rstc->acquired = false;
610 }
611 EXPORT_SYMBOL_GPL(reset_control_release);
612
613 static struct reset_control *__reset_control_get_internal(
614                                 struct reset_controller_dev *rcdev,
615                                 unsigned int index, bool shared, bool acquired)
616 {
617         struct reset_control *rstc;
618
619         lockdep_assert_held(&reset_list_mutex);
620
621         list_for_each_entry(rstc, &rcdev->reset_control_head, list) {
622                 if (rstc->id == index) {
623                         /*
624                          * Allow creating a secondary exclusive reset_control
625                          * that is initially not acquired for an already
626                          * controlled reset line.
627                          */
628                         if (!rstc->shared && !shared && !acquired)
629                                 break;
630
631                         if (WARN_ON(!rstc->shared || !shared))
632                                 return ERR_PTR(-EBUSY);
633
634                         kref_get(&rstc->refcnt);
635                         return rstc;
636                 }
637         }
638
639         rstc = kzalloc(sizeof(*rstc), GFP_KERNEL);
640         if (!rstc)
641                 return ERR_PTR(-ENOMEM);
642
643         try_module_get(rcdev->owner);
644
645         rstc->rcdev = rcdev;
646         list_add(&rstc->list, &rcdev->reset_control_head);
647         rstc->id = index;
648         kref_init(&rstc->refcnt);
649         rstc->acquired = acquired;
650         rstc->shared = shared;
651
652         return rstc;
653 }
654
655 static void __reset_control_release(struct kref *kref)
656 {
657         struct reset_control *rstc = container_of(kref, struct reset_control,
658                                                   refcnt);
659
660         lockdep_assert_held(&reset_list_mutex);
661
662         module_put(rstc->rcdev->owner);
663
664         list_del(&rstc->list);
665         kfree(rstc);
666 }
667
668 static void __reset_control_put_internal(struct reset_control *rstc)
669 {
670         lockdep_assert_held(&reset_list_mutex);
671
672         kref_put(&rstc->refcnt, __reset_control_release);
673 }
674
675 struct reset_control *__of_reset_control_get(struct device_node *node,
676                                      const char *id, int index, bool shared,
677                                      bool optional, bool acquired)
678 {
679         struct reset_control *rstc;
680         struct reset_controller_dev *r, *rcdev;
681         struct of_phandle_args args;
682         int rstc_id;
683         int ret;
684
685         if (!node)
686                 return ERR_PTR(-EINVAL);
687
688         if (id) {
689                 index = of_property_match_string(node,
690                                                  "reset-names", id);
691                 if (index == -EILSEQ)
692                         return ERR_PTR(index);
693                 if (index < 0)
694                         return optional ? NULL : ERR_PTR(-ENOENT);
695         }
696
697         ret = of_parse_phandle_with_args(node, "resets", "#reset-cells",
698                                          index, &args);
699         if (ret == -EINVAL)
700                 return ERR_PTR(ret);
701         if (ret)
702                 return optional ? NULL : ERR_PTR(ret);
703
704         mutex_lock(&reset_list_mutex);
705         rcdev = NULL;
706         list_for_each_entry(r, &reset_controller_list, list) {
707                 if (args.np == r->of_node) {
708                         rcdev = r;
709                         break;
710                 }
711         }
712
713         if (!rcdev) {
714                 rstc = ERR_PTR(-EPROBE_DEFER);
715                 goto out;
716         }
717
718         if (WARN_ON(args.args_count != rcdev->of_reset_n_cells)) {
719                 rstc = ERR_PTR(-EINVAL);
720                 goto out;
721         }
722
723         rstc_id = rcdev->of_xlate(rcdev, &args);
724         if (rstc_id < 0) {
725                 rstc = ERR_PTR(rstc_id);
726                 goto out;
727         }
728
729         /* reset_list_mutex also protects the rcdev's reset_control list */
730         rstc = __reset_control_get_internal(rcdev, rstc_id, shared, acquired);
731
732 out:
733         mutex_unlock(&reset_list_mutex);
734         of_node_put(args.np);
735
736         return rstc;
737 }
738 EXPORT_SYMBOL_GPL(__of_reset_control_get);
739
740 static struct reset_controller_dev *
741 __reset_controller_by_name(const char *name)
742 {
743         struct reset_controller_dev *rcdev;
744
745         lockdep_assert_held(&reset_list_mutex);
746
747         list_for_each_entry(rcdev, &reset_controller_list, list) {
748                 if (!rcdev->dev)
749                         continue;
750
751                 if (!strcmp(name, dev_name(rcdev->dev)))
752                         return rcdev;
753         }
754
755         return NULL;
756 }
757
758 static struct reset_control *
759 __reset_control_get_from_lookup(struct device *dev, const char *con_id,
760                                 bool shared, bool optional, bool acquired)
761 {
762         const struct reset_control_lookup *lookup;
763         struct reset_controller_dev *rcdev;
764         const char *dev_id = dev_name(dev);
765         struct reset_control *rstc = NULL;
766
767         mutex_lock(&reset_lookup_mutex);
768
769         list_for_each_entry(lookup, &reset_lookup_list, list) {
770                 if (strcmp(lookup->dev_id, dev_id))
771                         continue;
772
773                 if ((!con_id && !lookup->con_id) ||
774                     ((con_id && lookup->con_id) &&
775                      !strcmp(con_id, lookup->con_id))) {
776                         mutex_lock(&reset_list_mutex);
777                         rcdev = __reset_controller_by_name(lookup->provider);
778                         if (!rcdev) {
779                                 mutex_unlock(&reset_list_mutex);
780                                 mutex_unlock(&reset_lookup_mutex);
781                                 /* Reset provider may not be ready yet. */
782                                 return ERR_PTR(-EPROBE_DEFER);
783                         }
784
785                         rstc = __reset_control_get_internal(rcdev,
786                                                             lookup->index,
787                                                             shared, acquired);
788                         mutex_unlock(&reset_list_mutex);
789                         break;
790                 }
791         }
792
793         mutex_unlock(&reset_lookup_mutex);
794
795         if (!rstc)
796                 return optional ? NULL : ERR_PTR(-ENOENT);
797
798         return rstc;
799 }
800
801 struct reset_control *__reset_control_get(struct device *dev, const char *id,
802                                           int index, bool shared, bool optional,
803                                           bool acquired)
804 {
805         if (WARN_ON(shared && acquired))
806                 return ERR_PTR(-EINVAL);
807
808         if (dev->of_node)
809                 return __of_reset_control_get(dev->of_node, id, index, shared,
810                                               optional, acquired);
811
812         return __reset_control_get_from_lookup(dev, id, shared, optional,
813                                                acquired);
814 }
815 EXPORT_SYMBOL_GPL(__reset_control_get);
816
817 static void reset_control_array_put(struct reset_control_array *resets)
818 {
819         int i;
820
821         mutex_lock(&reset_list_mutex);
822         for (i = 0; i < resets->num_rstcs; i++)
823                 __reset_control_put_internal(resets->rstc[i]);
824         mutex_unlock(&reset_list_mutex);
825         kfree(resets);
826 }
827
828 /**
829  * reset_control_put - free the reset controller
830  * @rstc: reset controller
831  */
832 void reset_control_put(struct reset_control *rstc)
833 {
834         if (IS_ERR_OR_NULL(rstc))
835                 return;
836
837         if (reset_control_is_array(rstc)) {
838                 reset_control_array_put(rstc_to_array(rstc));
839                 return;
840         }
841
842         mutex_lock(&reset_list_mutex);
843         __reset_control_put_internal(rstc);
844         mutex_unlock(&reset_list_mutex);
845 }
846 EXPORT_SYMBOL_GPL(reset_control_put);
847
848 static void devm_reset_control_release(struct device *dev, void *res)
849 {
850         reset_control_put(*(struct reset_control **)res);
851 }
852
853 struct reset_control *__devm_reset_control_get(struct device *dev,
854                                      const char *id, int index, bool shared,
855                                      bool optional, bool acquired)
856 {
857         struct reset_control **ptr, *rstc;
858
859         ptr = devres_alloc(devm_reset_control_release, sizeof(*ptr),
860                            GFP_KERNEL);
861         if (!ptr)
862                 return ERR_PTR(-ENOMEM);
863
864         rstc = __reset_control_get(dev, id, index, shared, optional, acquired);
865         if (IS_ERR_OR_NULL(rstc)) {
866                 devres_free(ptr);
867                 return rstc;
868         }
869
870         *ptr = rstc;
871         devres_add(dev, ptr);
872
873         return rstc;
874 }
875 EXPORT_SYMBOL_GPL(__devm_reset_control_get);
876
877 /**
878  * __device_reset - find reset controller associated with the device
879  *                  and perform reset
880  * @dev: device to be reset by the controller
881  * @optional: whether it is optional to reset the device
882  *
883  * Convenience wrapper for __reset_control_get() and reset_control_reset().
884  * This is useful for the common case of devices with single, dedicated reset
885  * lines.
886  */
887 int __device_reset(struct device *dev, bool optional)
888 {
889         struct reset_control *rstc;
890         int ret;
891
892         rstc = __reset_control_get(dev, NULL, 0, 0, optional, true);
893         if (IS_ERR(rstc))
894                 return PTR_ERR(rstc);
895
896         ret = reset_control_reset(rstc);
897
898         reset_control_put(rstc);
899
900         return ret;
901 }
902 EXPORT_SYMBOL_GPL(__device_reset);
903
904 /*
905  * APIs to manage an array of reset controls.
906  */
907
908 /**
909  * of_reset_control_get_count - Count number of resets available with a device
910  *
911  * @node: device node that contains 'resets'.
912  *
913  * Returns positive reset count on success, or error number on failure and
914  * on count being zero.
915  */
916 static int of_reset_control_get_count(struct device_node *node)
917 {
918         int count;
919
920         if (!node)
921                 return -EINVAL;
922
923         count = of_count_phandle_with_args(node, "resets", "#reset-cells");
924         if (count == 0)
925                 count = -ENOENT;
926
927         return count;
928 }
929
930 /**
931  * of_reset_control_array_get - Get a list of reset controls using
932  *                              device node.
933  *
934  * @np: device node for the device that requests the reset controls array
935  * @shared: whether reset controls are shared or not
936  * @optional: whether it is optional to get the reset controls
937  * @acquired: only one reset control may be acquired for a given controller
938  *            and ID
939  *
940  * Returns pointer to allocated reset_control on success or error on failure
941  */
942 struct reset_control *
943 of_reset_control_array_get(struct device_node *np, bool shared, bool optional,
944                            bool acquired)
945 {
946         struct reset_control_array *resets;
947         struct reset_control *rstc;
948         int num, i;
949
950         num = of_reset_control_get_count(np);
951         if (num < 0)
952                 return optional ? NULL : ERR_PTR(num);
953
954         resets = kzalloc(struct_size(resets, rstc, num), GFP_KERNEL);
955         if (!resets)
956                 return ERR_PTR(-ENOMEM);
957
958         for (i = 0; i < num; i++) {
959                 rstc = __of_reset_control_get(np, NULL, i, shared, optional,
960                                               acquired);
961                 if (IS_ERR(rstc))
962                         goto err_rst;
963                 resets->rstc[i] = rstc;
964         }
965         resets->num_rstcs = num;
966         resets->base.array = true;
967
968         return &resets->base;
969
970 err_rst:
971         mutex_lock(&reset_list_mutex);
972         while (--i >= 0)
973                 __reset_control_put_internal(resets->rstc[i]);
974         mutex_unlock(&reset_list_mutex);
975
976         kfree(resets);
977
978         return rstc;
979 }
980 EXPORT_SYMBOL_GPL(of_reset_control_array_get);
981
982 /**
983  * devm_reset_control_array_get - Resource managed reset control array get
984  *
985  * @dev: device that requests the list of reset controls
986  * @shared: whether reset controls are shared or not
987  * @optional: whether it is optional to get the reset controls
988  *
989  * The reset control array APIs are intended for a list of resets
990  * that just have to be asserted or deasserted, without any
991  * requirements on the order.
992  *
993  * Returns pointer to allocated reset_control on success or error on failure
994  */
995 struct reset_control *
996 devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
997 {
998         struct reset_control **ptr, *rstc;
999
1000         ptr = devres_alloc(devm_reset_control_release, sizeof(*ptr),
1001                            GFP_KERNEL);
1002         if (!ptr)
1003                 return ERR_PTR(-ENOMEM);
1004
1005         rstc = of_reset_control_array_get(dev->of_node, shared, optional, true);
1006         if (IS_ERR_OR_NULL(rstc)) {
1007                 devres_free(ptr);
1008                 return rstc;
1009         }
1010
1011         *ptr = rstc;
1012         devres_add(dev, ptr);
1013
1014         return rstc;
1015 }
1016 EXPORT_SYMBOL_GPL(devm_reset_control_array_get);
1017
1018 static int reset_control_get_count_from_lookup(struct device *dev)
1019 {
1020         const struct reset_control_lookup *lookup;
1021         const char *dev_id;
1022         int count = 0;
1023
1024         if (!dev)
1025                 return -EINVAL;
1026
1027         dev_id = dev_name(dev);
1028         mutex_lock(&reset_lookup_mutex);
1029
1030         list_for_each_entry(lookup, &reset_lookup_list, list) {
1031                 if (!strcmp(lookup->dev_id, dev_id))
1032                         count++;
1033         }
1034
1035         mutex_unlock(&reset_lookup_mutex);
1036
1037         if (count == 0)
1038                 count = -ENOENT;
1039
1040         return count;
1041 }
1042
1043 /**
1044  * reset_control_get_count - Count number of resets available with a device
1045  *
1046  * @dev: device for which to return the number of resets
1047  *
1048  * Returns positive reset count on success, or error number on failure and
1049  * on count being zero.
1050  */
1051 int reset_control_get_count(struct device *dev)
1052 {
1053         if (dev->of_node)
1054                 return of_reset_control_get_count(dev->of_node);
1055
1056         return reset_control_get_count_from_lookup(dev);
1057 }
1058 EXPORT_SYMBOL_GPL(reset_control_get_count);