Merge tag 'pwm/for-5.13-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/thierry...
[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_bulk_reset - reset the controlled devices in order
363  * @num_rstcs: number of entries in rstcs array
364  * @rstcs: array of struct reset_control_bulk_data with reset controls set
365  *
366  * Issue a reset on all provided reset controls, in order.
367  *
368  * See also: reset_control_reset()
369  */
370 int reset_control_bulk_reset(int num_rstcs,
371                              struct reset_control_bulk_data *rstcs)
372 {
373         int ret, i;
374
375         for (i = 0; i < num_rstcs; i++) {
376                 ret = reset_control_reset(rstcs[i].rstc);
377                 if (ret)
378                         return ret;
379         }
380
381         return 0;
382 }
383 EXPORT_SYMBOL_GPL(reset_control_bulk_reset);
384
385 /**
386  * reset_control_rearm - allow shared reset line to be re-triggered"
387  * @rstc: reset controller
388  *
389  * On a shared reset line the actual reset pulse is only triggered once for the
390  * lifetime of the reset_control instance, except if this call is used.
391  *
392  * Calls to this function must be balanced with calls to reset_control_reset,
393  * a warning is thrown in case triggered_count ever dips below 0.
394  *
395  * Consumers must not use reset_control_(de)assert on shared reset lines when
396  * reset_control_reset or reset_control_rearm have been used.
397  *
398  * If rstc is NULL the function will just return 0.
399  */
400 int reset_control_rearm(struct reset_control *rstc)
401 {
402         if (!rstc)
403                 return 0;
404
405         if (WARN_ON(IS_ERR(rstc)))
406                 return -EINVAL;
407
408         if (reset_control_is_array(rstc))
409                 return reset_control_array_rearm(rstc_to_array(rstc));
410
411         if (rstc->shared) {
412                 if (WARN_ON(atomic_read(&rstc->deassert_count) != 0))
413                         return -EINVAL;
414
415                 WARN_ON(atomic_dec_return(&rstc->triggered_count) < 0);
416         } else {
417                 if (!rstc->acquired)
418                         return -EPERM;
419         }
420
421         return 0;
422 }
423 EXPORT_SYMBOL_GPL(reset_control_rearm);
424
425 /**
426  * reset_control_assert - asserts the reset line
427  * @rstc: reset controller
428  *
429  * Calling this on an exclusive reset controller guarantees that the reset
430  * will be asserted. When called on a shared reset controller the line may
431  * still be deasserted, as long as other users keep it so.
432  *
433  * For shared reset controls a driver cannot expect the hw's registers and
434  * internal state to be reset, but must be prepared for this to happen.
435  * Consumers must not use reset_control_reset on shared reset lines when
436  * reset_control_(de)assert has been used.
437  *
438  * If rstc is NULL it is an optional reset and the function will just
439  * return 0.
440  */
441 int reset_control_assert(struct reset_control *rstc)
442 {
443         if (!rstc)
444                 return 0;
445
446         if (WARN_ON(IS_ERR(rstc)))
447                 return -EINVAL;
448
449         if (reset_control_is_array(rstc))
450                 return reset_control_array_assert(rstc_to_array(rstc));
451
452         if (rstc->shared) {
453                 if (WARN_ON(atomic_read(&rstc->triggered_count) != 0))
454                         return -EINVAL;
455
456                 if (WARN_ON(atomic_read(&rstc->deassert_count) == 0))
457                         return -EINVAL;
458
459                 if (atomic_dec_return(&rstc->deassert_count) != 0)
460                         return 0;
461
462                 /*
463                  * Shared reset controls allow the reset line to be in any state
464                  * after this call, so doing nothing is a valid option.
465                  */
466                 if (!rstc->rcdev->ops->assert)
467                         return 0;
468         } else {
469                 /*
470                  * If the reset controller does not implement .assert(), there
471                  * is no way to guarantee that the reset line is asserted after
472                  * this call.
473                  */
474                 if (!rstc->rcdev->ops->assert)
475                         return -ENOTSUPP;
476
477                 if (!rstc->acquired) {
478                         WARN(1, "reset %s (ID: %u) is not acquired\n",
479                              rcdev_name(rstc->rcdev), rstc->id);
480                         return -EPERM;
481                 }
482         }
483
484         return rstc->rcdev->ops->assert(rstc->rcdev, rstc->id);
485 }
486 EXPORT_SYMBOL_GPL(reset_control_assert);
487
488 /**
489  * reset_control_bulk_assert - asserts the reset lines in order
490  * @num_rstcs: number of entries in rstcs array
491  * @rstcs: array of struct reset_control_bulk_data with reset controls set
492  *
493  * Assert the reset lines for all provided reset controls, in order.
494  * If an assertion fails, already asserted resets are deasserted again.
495  *
496  * See also: reset_control_assert()
497  */
498 int reset_control_bulk_assert(int num_rstcs,
499                               struct reset_control_bulk_data *rstcs)
500 {
501         int ret, i;
502
503         for (i = 0; i < num_rstcs; i++) {
504                 ret = reset_control_assert(rstcs[i].rstc);
505                 if (ret)
506                         goto err;
507         }
508
509         return 0;
510
511 err:
512         while (i--)
513                 reset_control_deassert(rstcs[i].rstc);
514         return ret;
515 }
516 EXPORT_SYMBOL_GPL(reset_control_bulk_assert);
517
518 /**
519  * reset_control_deassert - deasserts the reset line
520  * @rstc: reset controller
521  *
522  * After calling this function, the reset is guaranteed to be deasserted.
523  * Consumers must not use reset_control_reset on shared reset lines when
524  * reset_control_(de)assert has been used.
525  *
526  * If rstc is NULL it is an optional reset and the function will just
527  * return 0.
528  */
529 int reset_control_deassert(struct reset_control *rstc)
530 {
531         if (!rstc)
532                 return 0;
533
534         if (WARN_ON(IS_ERR(rstc)))
535                 return -EINVAL;
536
537         if (reset_control_is_array(rstc))
538                 return reset_control_array_deassert(rstc_to_array(rstc));
539
540         if (rstc->shared) {
541                 if (WARN_ON(atomic_read(&rstc->triggered_count) != 0))
542                         return -EINVAL;
543
544                 if (atomic_inc_return(&rstc->deassert_count) != 1)
545                         return 0;
546         } else {
547                 if (!rstc->acquired) {
548                         WARN(1, "reset %s (ID: %u) is not acquired\n",
549                              rcdev_name(rstc->rcdev), rstc->id);
550                         return -EPERM;
551                 }
552         }
553
554         /*
555          * If the reset controller does not implement .deassert(), we assume
556          * that it handles self-deasserting reset lines via .reset(). In that
557          * case, the reset lines are deasserted by default. If that is not the
558          * case, the reset controller driver should implement .deassert() and
559          * return -ENOTSUPP.
560          */
561         if (!rstc->rcdev->ops->deassert)
562                 return 0;
563
564         return rstc->rcdev->ops->deassert(rstc->rcdev, rstc->id);
565 }
566 EXPORT_SYMBOL_GPL(reset_control_deassert);
567
568 /**
569  * reset_control_bulk_deassert - deasserts the reset lines in reverse order
570  * @num_rstcs: number of entries in rstcs array
571  * @rstcs: array of struct reset_control_bulk_data with reset controls set
572  *
573  * Deassert the reset lines for all provided reset controls, in reverse order.
574  * If a deassertion fails, already deasserted resets are asserted again.
575  *
576  * See also: reset_control_deassert()
577  */
578 int reset_control_bulk_deassert(int num_rstcs,
579                                 struct reset_control_bulk_data *rstcs)
580 {
581         int ret, i;
582
583         for (i = num_rstcs - 1; i >= 0; i--) {
584                 ret = reset_control_deassert(rstcs[i].rstc);
585                 if (ret)
586                         goto err;
587         }
588
589         return 0;
590
591 err:
592         while (i < num_rstcs)
593                 reset_control_assert(rstcs[i++].rstc);
594         return ret;
595 }
596 EXPORT_SYMBOL_GPL(reset_control_bulk_deassert);
597
598 /**
599  * reset_control_status - returns a negative errno if not supported, a
600  * positive value if the reset line is asserted, or zero if the reset
601  * line is not asserted or if the desc is NULL (optional reset).
602  * @rstc: reset controller
603  */
604 int reset_control_status(struct reset_control *rstc)
605 {
606         if (!rstc)
607                 return 0;
608
609         if (WARN_ON(IS_ERR(rstc)) || reset_control_is_array(rstc))
610                 return -EINVAL;
611
612         if (rstc->rcdev->ops->status)
613                 return rstc->rcdev->ops->status(rstc->rcdev, rstc->id);
614
615         return -ENOTSUPP;
616 }
617 EXPORT_SYMBOL_GPL(reset_control_status);
618
619 /**
620  * reset_control_acquire() - acquires a reset control for exclusive use
621  * @rstc: reset control
622  *
623  * This is used to explicitly acquire a reset control for exclusive use. Note
624  * that exclusive resets are requested as acquired by default. In order for a
625  * second consumer to be able to control the reset, the first consumer has to
626  * release it first. Typically the easiest way to achieve this is to call the
627  * reset_control_get_exclusive_released() to obtain an instance of the reset
628  * control. Such reset controls are not acquired by default.
629  *
630  * Consumers implementing shared access to an exclusive reset need to follow
631  * a specific protocol in order to work together. Before consumers can change
632  * a reset they must acquire exclusive access using reset_control_acquire().
633  * After they are done operating the reset, they must release exclusive access
634  * with a call to reset_control_release(). Consumers are not granted exclusive
635  * access to the reset as long as another consumer hasn't released a reset.
636  *
637  * See also: reset_control_release()
638  */
639 int reset_control_acquire(struct reset_control *rstc)
640 {
641         struct reset_control *rc;
642
643         if (!rstc)
644                 return 0;
645
646         if (WARN_ON(IS_ERR(rstc)))
647                 return -EINVAL;
648
649         if (reset_control_is_array(rstc))
650                 return reset_control_array_acquire(rstc_to_array(rstc));
651
652         mutex_lock(&reset_list_mutex);
653
654         if (rstc->acquired) {
655                 mutex_unlock(&reset_list_mutex);
656                 return 0;
657         }
658
659         list_for_each_entry(rc, &rstc->rcdev->reset_control_head, list) {
660                 if (rstc != rc && rstc->id == rc->id) {
661                         if (rc->acquired) {
662                                 mutex_unlock(&reset_list_mutex);
663                                 return -EBUSY;
664                         }
665                 }
666         }
667
668         rstc->acquired = true;
669
670         mutex_unlock(&reset_list_mutex);
671         return 0;
672 }
673 EXPORT_SYMBOL_GPL(reset_control_acquire);
674
675 /**
676  * reset_control_bulk_acquire - acquires reset controls for exclusive use
677  * @num_rstcs: number of entries in rstcs array
678  * @rstcs: array of struct reset_control_bulk_data with reset controls set
679  *
680  * This is used to explicitly acquire reset controls requested with
681  * reset_control_bulk_get_exclusive_release() for temporary exclusive use.
682  *
683  * See also: reset_control_acquire(), reset_control_bulk_release()
684  */
685 int reset_control_bulk_acquire(int num_rstcs,
686                                struct reset_control_bulk_data *rstcs)
687 {
688         int ret, i;
689
690         for (i = 0; i < num_rstcs; i++) {
691                 ret = reset_control_acquire(rstcs[i].rstc);
692                 if (ret)
693                         goto err;
694         }
695
696         return 0;
697
698 err:
699         while (i--)
700                 reset_control_release(rstcs[i].rstc);
701         return ret;
702 }
703 EXPORT_SYMBOL_GPL(reset_control_bulk_acquire);
704
705 /**
706  * reset_control_release() - releases exclusive access to a reset control
707  * @rstc: reset control
708  *
709  * Releases exclusive access right to a reset control previously obtained by a
710  * call to reset_control_acquire(). Until a consumer calls this function, no
711  * other consumers will be granted exclusive access.
712  *
713  * See also: reset_control_acquire()
714  */
715 void reset_control_release(struct reset_control *rstc)
716 {
717         if (!rstc || WARN_ON(IS_ERR(rstc)))
718                 return;
719
720         if (reset_control_is_array(rstc))
721                 reset_control_array_release(rstc_to_array(rstc));
722         else
723                 rstc->acquired = false;
724 }
725 EXPORT_SYMBOL_GPL(reset_control_release);
726
727 /**
728  * reset_control_bulk_release() - releases exclusive access to reset controls
729  * @num_rstcs: number of entries in rstcs array
730  * @rstcs: array of struct reset_control_bulk_data with reset controls set
731  *
732  * Releases exclusive access right to reset controls previously obtained by a
733  * call to reset_control_bulk_acquire().
734  *
735  * See also: reset_control_release(), reset_control_bulk_acquire()
736  */
737 void reset_control_bulk_release(int num_rstcs,
738                                 struct reset_control_bulk_data *rstcs)
739 {
740         int i;
741
742         for (i = 0; i < num_rstcs; i++)
743                 reset_control_release(rstcs[i].rstc);
744 }
745 EXPORT_SYMBOL_GPL(reset_control_bulk_release);
746
747 static struct reset_control *__reset_control_get_internal(
748                                 struct reset_controller_dev *rcdev,
749                                 unsigned int index, bool shared, bool acquired)
750 {
751         struct reset_control *rstc;
752
753         lockdep_assert_held(&reset_list_mutex);
754
755         list_for_each_entry(rstc, &rcdev->reset_control_head, list) {
756                 if (rstc->id == index) {
757                         /*
758                          * Allow creating a secondary exclusive reset_control
759                          * that is initially not acquired for an already
760                          * controlled reset line.
761                          */
762                         if (!rstc->shared && !shared && !acquired)
763                                 break;
764
765                         if (WARN_ON(!rstc->shared || !shared))
766                                 return ERR_PTR(-EBUSY);
767
768                         kref_get(&rstc->refcnt);
769                         return rstc;
770                 }
771         }
772
773         rstc = kzalloc(sizeof(*rstc), GFP_KERNEL);
774         if (!rstc)
775                 return ERR_PTR(-ENOMEM);
776
777         try_module_get(rcdev->owner);
778
779         rstc->rcdev = rcdev;
780         list_add(&rstc->list, &rcdev->reset_control_head);
781         rstc->id = index;
782         kref_init(&rstc->refcnt);
783         rstc->acquired = acquired;
784         rstc->shared = shared;
785
786         return rstc;
787 }
788
789 static void __reset_control_release(struct kref *kref)
790 {
791         struct reset_control *rstc = container_of(kref, struct reset_control,
792                                                   refcnt);
793
794         lockdep_assert_held(&reset_list_mutex);
795
796         module_put(rstc->rcdev->owner);
797
798         list_del(&rstc->list);
799         kfree(rstc);
800 }
801
802 static void __reset_control_put_internal(struct reset_control *rstc)
803 {
804         lockdep_assert_held(&reset_list_mutex);
805
806         kref_put(&rstc->refcnt, __reset_control_release);
807 }
808
809 struct reset_control *__of_reset_control_get(struct device_node *node,
810                                      const char *id, int index, bool shared,
811                                      bool optional, bool acquired)
812 {
813         struct reset_control *rstc;
814         struct reset_controller_dev *r, *rcdev;
815         struct of_phandle_args args;
816         int rstc_id;
817         int ret;
818
819         if (!node)
820                 return ERR_PTR(-EINVAL);
821
822         if (id) {
823                 index = of_property_match_string(node,
824                                                  "reset-names", id);
825                 if (index == -EILSEQ)
826                         return ERR_PTR(index);
827                 if (index < 0)
828                         return optional ? NULL : ERR_PTR(-ENOENT);
829         }
830
831         ret = of_parse_phandle_with_args(node, "resets", "#reset-cells",
832                                          index, &args);
833         if (ret == -EINVAL)
834                 return ERR_PTR(ret);
835         if (ret)
836                 return optional ? NULL : ERR_PTR(ret);
837
838         mutex_lock(&reset_list_mutex);
839         rcdev = NULL;
840         list_for_each_entry(r, &reset_controller_list, list) {
841                 if (args.np == r->of_node) {
842                         rcdev = r;
843                         break;
844                 }
845         }
846
847         if (!rcdev) {
848                 rstc = ERR_PTR(-EPROBE_DEFER);
849                 goto out;
850         }
851
852         if (WARN_ON(args.args_count != rcdev->of_reset_n_cells)) {
853                 rstc = ERR_PTR(-EINVAL);
854                 goto out;
855         }
856
857         rstc_id = rcdev->of_xlate(rcdev, &args);
858         if (rstc_id < 0) {
859                 rstc = ERR_PTR(rstc_id);
860                 goto out;
861         }
862
863         /* reset_list_mutex also protects the rcdev's reset_control list */
864         rstc = __reset_control_get_internal(rcdev, rstc_id, shared, acquired);
865
866 out:
867         mutex_unlock(&reset_list_mutex);
868         of_node_put(args.np);
869
870         return rstc;
871 }
872 EXPORT_SYMBOL_GPL(__of_reset_control_get);
873
874 static struct reset_controller_dev *
875 __reset_controller_by_name(const char *name)
876 {
877         struct reset_controller_dev *rcdev;
878
879         lockdep_assert_held(&reset_list_mutex);
880
881         list_for_each_entry(rcdev, &reset_controller_list, list) {
882                 if (!rcdev->dev)
883                         continue;
884
885                 if (!strcmp(name, dev_name(rcdev->dev)))
886                         return rcdev;
887         }
888
889         return NULL;
890 }
891
892 static struct reset_control *
893 __reset_control_get_from_lookup(struct device *dev, const char *con_id,
894                                 bool shared, bool optional, bool acquired)
895 {
896         const struct reset_control_lookup *lookup;
897         struct reset_controller_dev *rcdev;
898         const char *dev_id = dev_name(dev);
899         struct reset_control *rstc = NULL;
900
901         mutex_lock(&reset_lookup_mutex);
902
903         list_for_each_entry(lookup, &reset_lookup_list, list) {
904                 if (strcmp(lookup->dev_id, dev_id))
905                         continue;
906
907                 if ((!con_id && !lookup->con_id) ||
908                     ((con_id && lookup->con_id) &&
909                      !strcmp(con_id, lookup->con_id))) {
910                         mutex_lock(&reset_list_mutex);
911                         rcdev = __reset_controller_by_name(lookup->provider);
912                         if (!rcdev) {
913                                 mutex_unlock(&reset_list_mutex);
914                                 mutex_unlock(&reset_lookup_mutex);
915                                 /* Reset provider may not be ready yet. */
916                                 return ERR_PTR(-EPROBE_DEFER);
917                         }
918
919                         rstc = __reset_control_get_internal(rcdev,
920                                                             lookup->index,
921                                                             shared, acquired);
922                         mutex_unlock(&reset_list_mutex);
923                         break;
924                 }
925         }
926
927         mutex_unlock(&reset_lookup_mutex);
928
929         if (!rstc)
930                 return optional ? NULL : ERR_PTR(-ENOENT);
931
932         return rstc;
933 }
934
935 struct reset_control *__reset_control_get(struct device *dev, const char *id,
936                                           int index, bool shared, bool optional,
937                                           bool acquired)
938 {
939         if (WARN_ON(shared && acquired))
940                 return ERR_PTR(-EINVAL);
941
942         if (dev->of_node)
943                 return __of_reset_control_get(dev->of_node, id, index, shared,
944                                               optional, acquired);
945
946         return __reset_control_get_from_lookup(dev, id, shared, optional,
947                                                acquired);
948 }
949 EXPORT_SYMBOL_GPL(__reset_control_get);
950
951 int __reset_control_bulk_get(struct device *dev, int num_rstcs,
952                              struct reset_control_bulk_data *rstcs,
953                              bool shared, bool optional, bool acquired)
954 {
955         int ret, i;
956
957         for (i = 0; i < num_rstcs; i++) {
958                 rstcs[i].rstc = __reset_control_get(dev, rstcs[i].id, 0,
959                                                     shared, optional, acquired);
960                 if (IS_ERR(rstcs[i].rstc)) {
961                         ret = PTR_ERR(rstcs[i].rstc);
962                         goto err;
963                 }
964         }
965
966         return 0;
967
968 err:
969         mutex_lock(&reset_list_mutex);
970         while (i--)
971                 __reset_control_put_internal(rstcs[i].rstc);
972         mutex_unlock(&reset_list_mutex);
973         return ret;
974 }
975 EXPORT_SYMBOL_GPL(__reset_control_bulk_get);
976
977 static void reset_control_array_put(struct reset_control_array *resets)
978 {
979         int i;
980
981         mutex_lock(&reset_list_mutex);
982         for (i = 0; i < resets->num_rstcs; i++)
983                 __reset_control_put_internal(resets->rstc[i]);
984         mutex_unlock(&reset_list_mutex);
985         kfree(resets);
986 }
987
988 /**
989  * reset_control_put - free the reset controller
990  * @rstc: reset controller
991  */
992 void reset_control_put(struct reset_control *rstc)
993 {
994         if (IS_ERR_OR_NULL(rstc))
995                 return;
996
997         if (reset_control_is_array(rstc)) {
998                 reset_control_array_put(rstc_to_array(rstc));
999                 return;
1000         }
1001
1002         mutex_lock(&reset_list_mutex);
1003         __reset_control_put_internal(rstc);
1004         mutex_unlock(&reset_list_mutex);
1005 }
1006 EXPORT_SYMBOL_GPL(reset_control_put);
1007
1008 /**
1009  * reset_control_bulk_put - free the reset controllers
1010  * @num_rstcs: number of entries in rstcs array
1011  * @rstcs: array of struct reset_control_bulk_data with reset controls set
1012  */
1013 void reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs)
1014 {
1015         mutex_lock(&reset_list_mutex);
1016         while (num_rstcs--) {
1017                 if (IS_ERR_OR_NULL(rstcs[num_rstcs].rstc))
1018                         continue;
1019                 __reset_control_put_internal(rstcs[num_rstcs].rstc);
1020         }
1021         mutex_unlock(&reset_list_mutex);
1022 }
1023 EXPORT_SYMBOL_GPL(reset_control_bulk_put);
1024
1025 static void devm_reset_control_release(struct device *dev, void *res)
1026 {
1027         reset_control_put(*(struct reset_control **)res);
1028 }
1029
1030 struct reset_control *__devm_reset_control_get(struct device *dev,
1031                                      const char *id, int index, bool shared,
1032                                      bool optional, bool acquired)
1033 {
1034         struct reset_control **ptr, *rstc;
1035
1036         ptr = devres_alloc(devm_reset_control_release, sizeof(*ptr),
1037                            GFP_KERNEL);
1038         if (!ptr)
1039                 return ERR_PTR(-ENOMEM);
1040
1041         rstc = __reset_control_get(dev, id, index, shared, optional, acquired);
1042         if (IS_ERR_OR_NULL(rstc)) {
1043                 devres_free(ptr);
1044                 return rstc;
1045         }
1046
1047         *ptr = rstc;
1048         devres_add(dev, ptr);
1049
1050         return rstc;
1051 }
1052 EXPORT_SYMBOL_GPL(__devm_reset_control_get);
1053
1054 struct reset_control_bulk_devres {
1055         int num_rstcs;
1056         struct reset_control_bulk_data *rstcs;
1057 };
1058
1059 static void devm_reset_control_bulk_release(struct device *dev, void *res)
1060 {
1061         struct reset_control_bulk_devres *devres = res;
1062
1063         reset_control_bulk_put(devres->num_rstcs, devres->rstcs);
1064 }
1065
1066 int __devm_reset_control_bulk_get(struct device *dev, int num_rstcs,
1067                                   struct reset_control_bulk_data *rstcs,
1068                                   bool shared, bool optional, bool acquired)
1069 {
1070         struct reset_control_bulk_devres *ptr;
1071         int ret;
1072
1073         ptr = devres_alloc(devm_reset_control_bulk_release, sizeof(*ptr),
1074                            GFP_KERNEL);
1075         if (!ptr)
1076                 return -ENOMEM;
1077
1078         ret = __reset_control_bulk_get(dev, num_rstcs, rstcs, shared, optional, acquired);
1079         if (ret < 0) {
1080                 devres_free(ptr);
1081                 return ret;
1082         }
1083
1084         ptr->num_rstcs = num_rstcs;
1085         ptr->rstcs = rstcs;
1086         devres_add(dev, ptr);
1087
1088         return 0;
1089 }
1090 EXPORT_SYMBOL_GPL(__devm_reset_control_bulk_get);
1091
1092 /**
1093  * __device_reset - find reset controller associated with the device
1094  *                  and perform reset
1095  * @dev: device to be reset by the controller
1096  * @optional: whether it is optional to reset the device
1097  *
1098  * Convenience wrapper for __reset_control_get() and reset_control_reset().
1099  * This is useful for the common case of devices with single, dedicated reset
1100  * lines.
1101  */
1102 int __device_reset(struct device *dev, bool optional)
1103 {
1104         struct reset_control *rstc;
1105         int ret;
1106
1107         rstc = __reset_control_get(dev, NULL, 0, 0, optional, true);
1108         if (IS_ERR(rstc))
1109                 return PTR_ERR(rstc);
1110
1111         ret = reset_control_reset(rstc);
1112
1113         reset_control_put(rstc);
1114
1115         return ret;
1116 }
1117 EXPORT_SYMBOL_GPL(__device_reset);
1118
1119 /*
1120  * APIs to manage an array of reset controls.
1121  */
1122
1123 /**
1124  * of_reset_control_get_count - Count number of resets available with a device
1125  *
1126  * @node: device node that contains 'resets'.
1127  *
1128  * Returns positive reset count on success, or error number on failure and
1129  * on count being zero.
1130  */
1131 static int of_reset_control_get_count(struct device_node *node)
1132 {
1133         int count;
1134
1135         if (!node)
1136                 return -EINVAL;
1137
1138         count = of_count_phandle_with_args(node, "resets", "#reset-cells");
1139         if (count == 0)
1140                 count = -ENOENT;
1141
1142         return count;
1143 }
1144
1145 /**
1146  * of_reset_control_array_get - Get a list of reset controls using
1147  *                              device node.
1148  *
1149  * @np: device node for the device that requests the reset controls array
1150  * @shared: whether reset controls are shared or not
1151  * @optional: whether it is optional to get the reset controls
1152  * @acquired: only one reset control may be acquired for a given controller
1153  *            and ID
1154  *
1155  * Returns pointer to allocated reset_control on success or error on failure
1156  */
1157 struct reset_control *
1158 of_reset_control_array_get(struct device_node *np, bool shared, bool optional,
1159                            bool acquired)
1160 {
1161         struct reset_control_array *resets;
1162         struct reset_control *rstc;
1163         int num, i;
1164
1165         num = of_reset_control_get_count(np);
1166         if (num < 0)
1167                 return optional ? NULL : ERR_PTR(num);
1168
1169         resets = kzalloc(struct_size(resets, rstc, num), GFP_KERNEL);
1170         if (!resets)
1171                 return ERR_PTR(-ENOMEM);
1172
1173         for (i = 0; i < num; i++) {
1174                 rstc = __of_reset_control_get(np, NULL, i, shared, optional,
1175                                               acquired);
1176                 if (IS_ERR(rstc))
1177                         goto err_rst;
1178                 resets->rstc[i] = rstc;
1179         }
1180         resets->num_rstcs = num;
1181         resets->base.array = true;
1182
1183         return &resets->base;
1184
1185 err_rst:
1186         mutex_lock(&reset_list_mutex);
1187         while (--i >= 0)
1188                 __reset_control_put_internal(resets->rstc[i]);
1189         mutex_unlock(&reset_list_mutex);
1190
1191         kfree(resets);
1192
1193         return rstc;
1194 }
1195 EXPORT_SYMBOL_GPL(of_reset_control_array_get);
1196
1197 /**
1198  * devm_reset_control_array_get - Resource managed reset control array get
1199  *
1200  * @dev: device that requests the list of reset controls
1201  * @shared: whether reset controls are shared or not
1202  * @optional: whether it is optional to get the reset controls
1203  *
1204  * The reset control array APIs are intended for a list of resets
1205  * that just have to be asserted or deasserted, without any
1206  * requirements on the order.
1207  *
1208  * Returns pointer to allocated reset_control on success or error on failure
1209  */
1210 struct reset_control *
1211 devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
1212 {
1213         struct reset_control **ptr, *rstc;
1214
1215         ptr = devres_alloc(devm_reset_control_release, sizeof(*ptr),
1216                            GFP_KERNEL);
1217         if (!ptr)
1218                 return ERR_PTR(-ENOMEM);
1219
1220         rstc = of_reset_control_array_get(dev->of_node, shared, optional, true);
1221         if (IS_ERR_OR_NULL(rstc)) {
1222                 devres_free(ptr);
1223                 return rstc;
1224         }
1225
1226         *ptr = rstc;
1227         devres_add(dev, ptr);
1228
1229         return rstc;
1230 }
1231 EXPORT_SYMBOL_GPL(devm_reset_control_array_get);
1232
1233 static int reset_control_get_count_from_lookup(struct device *dev)
1234 {
1235         const struct reset_control_lookup *lookup;
1236         const char *dev_id;
1237         int count = 0;
1238
1239         if (!dev)
1240                 return -EINVAL;
1241
1242         dev_id = dev_name(dev);
1243         mutex_lock(&reset_lookup_mutex);
1244
1245         list_for_each_entry(lookup, &reset_lookup_list, list) {
1246                 if (!strcmp(lookup->dev_id, dev_id))
1247                         count++;
1248         }
1249
1250         mutex_unlock(&reset_lookup_mutex);
1251
1252         if (count == 0)
1253                 count = -ENOENT;
1254
1255         return count;
1256 }
1257
1258 /**
1259  * reset_control_get_count - Count number of resets available with a device
1260  *
1261  * @dev: device for which to return the number of resets
1262  *
1263  * Returns positive reset count on success, or error number on failure and
1264  * on count being zero.
1265  */
1266 int reset_control_get_count(struct device *dev)
1267 {
1268         if (dev->of_node)
1269                 return of_reset_control_get_count(dev->of_node);
1270
1271         return reset_control_get_count_from_lookup(dev);
1272 }
1273 EXPORT_SYMBOL_GPL(reset_control_get_count);