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