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