drivers/reset/core.c

   1 /*
   2  * Reset Controller framework
   3  *
   4  * Copyright 2013 Philipp Zabel, Pengutronix
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  */
  11 #include <linux/atomic.h>
  12 #include <linux/device.h>
  13 #include <linux/err.h>
  14 #include <linux/export.h>
  15 #include <linux/kernel.h>
  16 #include <linux/kref.h>
  17 #include <linux/module.h>
  18 #include <linux/of.h>
  19 #include <linux/reset.h>
  20 #include <linux/reset-controller.h>
  21 #include <linux/slab.h>
  22
  23 static DEFINE_MUTEX(reset_list_mutex);
  24 static LIST_HEAD(reset_controller_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  * @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 shared;
  46         bool array;
  47         atomic_t deassert_count;
  48         atomic_t triggered_count;
  49 };
  50
  51 /**
  52  * struct reset_control_array - an array of reset controls
  53  * @base: reset control for compatibility with reset control API functions
  54  * @num_rstcs: number of reset controls
  55  * @rstc: array of reset controls
  56  */
  57 struct reset_control_array {
  58         struct reset_control base;
  59         unsigned int num_rstcs;
  60         struct reset_control *rstc[];
  61 };
  62
  63 /**
  64  * of_reset_simple_xlate - translate reset_spec to the reset line number
  65  * @rcdev: a pointer to the reset controller device
  66  * @reset_spec: reset line specifier as found in the device tree
  67  * @flags: a flags pointer to fill in (optional)
  68  *
  69  * This simple translation function should be used for reset controllers
  70  * with 1:1 mapping, where reset lines can be indexed by number without gaps.
  71  */
  72 static int of_reset_simple_xlate(struct reset_controller_dev *rcdev,
  73                           const struct of_phandle_args *reset_spec)
  74 {
  75         if (reset_spec->args[0] >= rcdev->nr_resets)
  76                 return -EINVAL;
  77
  78         return reset_spec->args[0];
  79 }
  80
  81 /**
  82  * reset_controller_register - register a reset controller device
  83  * @rcdev: a pointer to the initialized reset controller device
  84  */
  85 int reset_controller_register(struct reset_controller_dev *rcdev)
  86 {
  87         if (!rcdev->of_xlate) {
  88                 rcdev->of_reset_n_cells = 1;
  89                 rcdev->of_xlate = of_reset_simple_xlate;
  90         }
  91
  92         INIT_LIST_HEAD(&rcdev->reset_control_head);
  93
  94         mutex_lock(&reset_list_mutex);
  95         list_add(&rcdev->list, &reset_controller_list);
  96         mutex_unlock(&reset_list_mutex);
  97
  98         return 0;
  99 }
 100 EXPORT_SYMBOL_GPL(reset_controller_register);
 101
 102 /**
 103  * reset_controller_unregister - unregister a reset controller device
 104  * @rcdev: a pointer to the reset controller device
 105  */
 106 void reset_controller_unregister(struct reset_controller_dev *rcdev)
 107 {
 108         mutex_lock(&reset_list_mutex);
 109         list_del(&rcdev->list);
 110         mutex_unlock(&reset_list_mutex);
 111 }
 112 EXPORT_SYMBOL_GPL(reset_controller_unregister);
 113
 114 static void devm_reset_controller_release(struct device *dev, void *res)
 115 {
 116         reset_controller_unregister(*(struct reset_controller_dev **)res);
 117 }
 118
 119 /**
 120  * devm_reset_controller_register - resource managed reset_controller_register()
 121  * @dev: device that is registering this reset controller
 122  * @rcdev: a pointer to the initialized reset controller device
 123  *
 124  * Managed reset_controller_register(). For reset controllers registered by
 125  * this function, reset_controller_unregister() is automatically called on
 126  * driver detach. See reset_controller_register() for more information.
 127  */
 128 int devm_reset_controller_register(struct device *dev,
 129                                    struct reset_controller_dev *rcdev)
 130 {
 131         struct reset_controller_dev **rcdevp;
 132         int ret;
 133
 134         rcdevp = devres_alloc(devm_reset_controller_release, sizeof(*rcdevp),
 135                               GFP_KERNEL);
 136         if (!rcdevp)
 137                 return -ENOMEM;
 138
 139         ret = reset_controller_register(rcdev);
 140         if (!ret) {
 141                 *rcdevp = rcdev;
 142                 devres_add(dev, rcdevp);
 143         } else {
 144                 devres_free(rcdevp);
 145         }
 146
 147         return ret;
 148 }
 149 EXPORT_SYMBOL_GPL(devm_reset_controller_register);
 150
 151 static inline struct reset_control_array *
 152 rstc_to_array(struct reset_control *rstc) {
 153         return container_of(rstc, struct reset_control_array, base);
 154 }
 155
 156 static int reset_control_array_reset(struct reset_control_array *resets)
 157 {
 158         int ret, i;
 159
 160         for (i = 0; i < resets->num_rstcs; i++) {
 161                 ret = reset_control_reset(resets->rstc[i]);
 162                 if (ret)
 163                         return ret;
 164         }
 165
 166         return 0;
 167 }
 168
 169 static int reset_control_array_assert(struct reset_control_array *resets)
 170 {
 171         int ret, i;
 172
 173         for (i = 0; i < resets->num_rstcs; i++) {
 174                 ret = reset_control_assert(resets->rstc[i]);
 175                 if (ret)
 176                         goto err;
 177         }
 178
 179         return 0;
 180
 181 err:
 182         while (i--)
 183                 reset_control_deassert(resets->rstc[i]);
 184         return ret;
 185 }
 186
 187 static int reset_control_array_deassert(struct reset_control_array *resets)
 188 {
 189         int ret, i;
 190
 191         for (i = 0; i < resets->num_rstcs; i++) {
 192                 ret = reset_control_deassert(resets->rstc[i]);
 193                 if (ret)
 194                         goto err;
 195         }
 196
 197         return 0;
 198
 199 err:
 200         while (i--)
 201                 reset_control_assert(resets->rstc[i]);
 202         return ret;
 203 }
 204
 205 static inline bool reset_control_is_array(struct reset_control *rstc)
 206 {
 207         return rstc->array;
 208 }
 209
 210 /**
 211  * reset_control_reset - reset the controlled device
 212  * @rstc: reset controller
 213  *
 214  * On a shared reset line the actual reset pulse is only triggered once for the
 215  * lifetime of the reset_control instance: for all but the first caller this is
 216  * a no-op.
 217  * Consumers must not use reset_control_(de)assert on shared reset lines when
 218  * reset_control_reset has been used.
 219  *
 220  * If rstc is NULL it is an optional reset and the function will just
 221  * return 0.
 222  */
 223 int reset_control_reset(struct reset_control *rstc)
 224 {
 225         int ret;
 226
 227         if (!rstc)
 228                 return 0;
 229
 230         if (WARN_ON(IS_ERR(rstc)))
 231                 return -EINVAL;
 232
 233         if (reset_control_is_array(rstc))
 234                 return reset_control_array_reset(rstc_to_array(rstc));
 235
 236         if (!rstc->rcdev->ops->reset)
 237                 return -ENOTSUPP;
 238
 239         if (rstc->shared) {
 240                 if (WARN_ON(atomic_read(&rstc->deassert_count) != 0))
 241                         return -EINVAL;
 242
 243                 if (atomic_inc_return(&rstc->triggered_count) != 1)
 244                         return 0;
 245         }
 246
 247         ret = rstc->rcdev->ops->reset(rstc->rcdev, rstc->id);
 248         if (rstc->shared && ret)
 249                 atomic_dec(&rstc->triggered_count);
 250
 251         return ret;
 252 }
 253 EXPORT_SYMBOL_GPL(reset_control_reset);
 254
 255 /**
 256  * reset_control_assert - asserts the reset line
 257  * @rstc: reset controller
 258  *
 259  * Calling this on an exclusive reset controller guarantees that the reset
 260  * will be asserted. When called on a shared reset controller the line may
 261  * still be deasserted, as long as other users keep it so.
 262  *
 263  * For shared reset controls a driver cannot expect the hw's registers and
 264  * internal state to be reset, but must be prepared for this to happen.
 265  * Consumers must not use reset_control_reset on shared reset lines when
 266  * reset_control_(de)assert has been used.
 267  * return 0.
 268  *
 269  * If rstc is NULL it is an optional reset and the function will just
 270  * return 0.
 271  */
 272 int reset_control_assert(struct reset_control *rstc)
 273 {
 274         if (!rstc)
 275                 return 0;
 276
 277         if (WARN_ON(IS_ERR(rstc)))
 278                 return -EINVAL;
 279
 280         if (reset_control_is_array(rstc))
 281                 return reset_control_array_assert(rstc_to_array(rstc));
 282
 283         if (rstc->shared) {
 284                 if (WARN_ON(atomic_read(&rstc->triggered_count) != 0))
 285                         return -EINVAL;
 286
 287                 if (WARN_ON(atomic_read(&rstc->deassert_count) == 0))
 288                         return -EINVAL;
 289
 290                 if (atomic_dec_return(&rstc->deassert_count) != 0)
 291                         return 0;
 292
 293                 /*
 294                  * Shared reset controls allow the reset line to be in any state
 295                  * after this call, so doing nothing is a valid option.
 296                  */
 297                 if (!rstc->rcdev->ops->assert)
 298                         return 0;
 299         } else {
 300                 /*
 301                  * If the reset controller does not implement .assert(), there
 302                  * is no way to guarantee that the reset line is asserted after
 303                  * this call.
 304                  */
 305                 if (!rstc->rcdev->ops->assert)
 306                         return -ENOTSUPP;
 307         }
 308
 309         return rstc->rcdev->ops->assert(rstc->rcdev, rstc->id);
 310 }
 311 EXPORT_SYMBOL_GPL(reset_control_assert);
 312
 313 /**
 314  * reset_control_deassert - deasserts the reset line
 315  * @rstc: reset controller
 316  *
 317  * After calling this function, the reset is guaranteed to be deasserted.
 318  * Consumers must not use reset_control_reset on shared reset lines when
 319  * reset_control_(de)assert has been used.
 320  * return 0.
 321  *
 322  * If rstc is NULL it is an optional reset and the function will just
 323  * return 0.
 324  */
 325 int reset_control_deassert(struct reset_control *rstc)
 326 {
 327         if (!rstc)
 328                 return 0;
 329
 330         if (WARN_ON(IS_ERR(rstc)))
 331                 return -EINVAL;
 332
 333         if (reset_control_is_array(rstc))
 334                 return reset_control_array_deassert(rstc_to_array(rstc));
 335
 336         if (rstc->shared) {
 337                 if (WARN_ON(atomic_read(&rstc->triggered_count) != 0))
 338                         return -EINVAL;
 339
 340                 if (atomic_inc_return(&rstc->deassert_count) != 1)
 341                         return 0;
 342         }
 343
 344         /*
 345          * If the reset controller does not implement .deassert(), we assume
 346          * that it handles self-deasserting reset lines via .reset(). In that
 347          * case, the reset lines are deasserted by default. If that is not the
 348          * case, the reset controller driver should implement .deassert() and
 349          * return -ENOTSUPP.
 350          */
 351         if (!rstc->rcdev->ops->deassert)
 352                 return 0;
 353
 354         return rstc->rcdev->ops->deassert(rstc->rcdev, rstc->id);
 355 }
 356 EXPORT_SYMBOL_GPL(reset_control_deassert);
 357
 358 /**
 359  * reset_control_status - returns a negative errno if not supported, a
 360  * positive value if the reset line is asserted, or zero if the reset
 361  * line is not asserted or if the desc is NULL (optional reset).
 362  * @rstc: reset controller
 363  */
 364 int reset_control_status(struct reset_control *rstc)
 365 {
 366         if (!rstc)
 367                 return 0;
 368
 369         if (WARN_ON(IS_ERR(rstc)) || reset_control_is_array(rstc))
 370                 return -EINVAL;
 371
 372         if (rstc->rcdev->ops->status)
 373                 return rstc->rcdev->ops->status(rstc->rcdev, rstc->id);
 374
 375         return -ENOTSUPP;
 376 }
 377 EXPORT_SYMBOL_GPL(reset_control_status);
 378
 379 static struct reset_control *__reset_control_get_internal(
 380                                 struct reset_controller_dev *rcdev,
 381                                 unsigned int index, bool shared)
 382 {
 383         struct reset_control *rstc;
 384
 385         lockdep_assert_held(&reset_list_mutex);
 386
 387         list_for_each_entry(rstc, &rcdev->reset_control_head, list) {
 388                 if (rstc->id == index) {
 389                         if (WARN_ON(!rstc->shared || !shared))
 390                                 return ERR_PTR(-EBUSY);
 391
 392                         kref_get(&rstc->refcnt);
 393                         return rstc;
 394                 }
 395         }
 396
 397         rstc = kzalloc(sizeof(*rstc), GFP_KERNEL);
 398         if (!rstc)
 399                 return ERR_PTR(-ENOMEM);
 400
 401         if (!try_module_get(rcdev->owner)) {
 402                 kfree(rstc);
 403                 return ERR_PTR(-ENODEV);
 404         }
 405
 406         rstc->rcdev = rcdev;
 407         list_add(&rstc->list, &rcdev->reset_control_head);
 408         rstc->id = index;
 409         kref_init(&rstc->refcnt);
 410         rstc->shared = shared;
 411
 412         return rstc;
 413 }
 414
 415 static void __reset_control_release(struct kref *kref)
 416 {
 417         struct reset_control *rstc = container_of(kref, struct reset_control,
 418                                                   refcnt);
 419
 420         lockdep_assert_held(&reset_list_mutex);
 421
 422         module_put(rstc->rcdev->owner);
 423
 424         list_del(&rstc->list);
 425         kfree(rstc);
 426 }
 427
 428 static void __reset_control_put_internal(struct reset_control *rstc)
 429 {
 430         lockdep_assert_held(&reset_list_mutex);
 431
 432         kref_put(&rstc->refcnt, __reset_control_release);
 433 }
 434
 435 struct reset_control *__of_reset_control_get(struct device_node *node,
 436                                      const char *id, int index, bool shared,
 437                                      bool optional)
 438 {
 439         struct reset_control *rstc;
 440         struct reset_controller_dev *r, *rcdev;
 441         struct of_phandle_args args;
 442         int rstc_id;
 443         int ret;
 444
 445         if (!node)
 446                 return ERR_PTR(-EINVAL);
 447
 448         if (id) {
 449                 index = of_property_match_string(node,
 450                                                  "reset-names", id);
 451                 if (index == -EILSEQ)
 452                         return ERR_PTR(index);
 453                 if (index < 0)
 454                         return optional ? NULL : ERR_PTR(-ENOENT);
 455         }
 456
 457         ret = of_parse_phandle_with_args(node, "resets", "#reset-cells",
 458                                          index, &args);
 459         if (ret == -EINVAL)
 460                 return ERR_PTR(ret);
 461         if (ret)
 462                 return optional ? NULL : ERR_PTR(ret);
 463
 464         mutex_lock(&reset_list_mutex);
 465         rcdev = NULL;
 466         list_for_each_entry(r, &reset_controller_list, list) {
 467                 if (args.np == r->of_node) {
 468                         rcdev = r;
 469                         break;
 470                 }
 471         }
 472
 473         if (!rcdev) {
 474                 rstc = ERR_PTR(-EPROBE_DEFER);
 475                 goto out;
 476         }
 477
 478         if (WARN_ON(args.args_count != rcdev->of_reset_n_cells)) {
 479                 rstc = ERR_PTR(-EINVAL);
 480                 goto out;
 481         }
 482
 483         rstc_id = rcdev->of_xlate(rcdev, &args);
 484         if (rstc_id < 0) {
 485                 rstc = ERR_PTR(rstc_id);
 486                 goto out;
 487         }
 488
 489         /* reset_list_mutex also protects the rcdev's reset_control list */
 490         rstc = __reset_control_get_internal(rcdev, rstc_id, shared);
 491
 492 out:
 493         mutex_unlock(&reset_list_mutex);
 494         of_node_put(args.np);
 495
 496         return rstc;
 497 }
 498 EXPORT_SYMBOL_GPL(__of_reset_control_get);
 499
 500 struct reset_control *__reset_control_get(struct device *dev, const char *id,
 501                                           int index, bool shared, bool optional)
 502 {
 503         if (dev->of_node)
 504                 return __of_reset_control_get(dev->of_node, id, index, shared,
 505                                               optional);
 506
 507         return optional ? NULL : ERR_PTR(-EINVAL);
 508 }
 509 EXPORT_SYMBOL_GPL(__reset_control_get);
 510
 511 static void reset_control_array_put(struct reset_control_array *resets)
 512 {
 513         int i;
 514
 515         mutex_lock(&reset_list_mutex);
 516         for (i = 0; i < resets->num_rstcs; i++)
 517                 __reset_control_put_internal(resets->rstc[i]);
 518         mutex_unlock(&reset_list_mutex);
 519         kfree(resets);
 520 }
 521
 522 /**
 523  * reset_control_put - free the reset controller
 524  * @rstc: reset controller
 525  */
 526 void reset_control_put(struct reset_control *rstc)
 527 {
 528         if (IS_ERR_OR_NULL(rstc))
 529                 return;
 530
 531         if (reset_control_is_array(rstc)) {
 532                 reset_control_array_put(rstc_to_array(rstc));
 533                 return;
 534         }
 535
 536         mutex_lock(&reset_list_mutex);
 537         __reset_control_put_internal(rstc);
 538         mutex_unlock(&reset_list_mutex);
 539 }
 540 EXPORT_SYMBOL_GPL(reset_control_put);
 541
 542 static void devm_reset_control_release(struct device *dev, void *res)
 543 {
 544         reset_control_put(*(struct reset_control **)res);
 545 }
 546
 547 struct reset_control *__devm_reset_control_get(struct device *dev,
 548                                      const char *id, int index, bool shared,
 549                                      bool optional)
 550 {
 551         struct reset_control **ptr, *rstc;
 552
 553         ptr = devres_alloc(devm_reset_control_release, sizeof(*ptr),
 554                            GFP_KERNEL);
 555         if (!ptr)
 556                 return ERR_PTR(-ENOMEM);
 557
 558         rstc = __reset_control_get(dev, id, index, shared, optional);
 559         if (!IS_ERR(rstc)) {
 560                 *ptr = rstc;
 561                 devres_add(dev, ptr);
 562         } else {
 563                 devres_free(ptr);
 564         }
 565
 566         return rstc;
 567 }
 568 EXPORT_SYMBOL_GPL(__devm_reset_control_get);
 569
 570 /**
 571  * device_reset - find reset controller associated with the device
 572  *                and perform reset
 573  * @dev: device to be reset by the controller
 574  * @optional: whether it is optional to reset the device
 575  *
 576  * Convenience wrapper for __reset_control_get() and reset_control_reset().
 577  * This is useful for the common case of devices with single, dedicated reset
 578  * lines.
 579  */
 580 int __device_reset(struct device *dev, bool optional)
 581 {
 582         struct reset_control *rstc;
 583         int ret;
 584
 585         rstc = __reset_control_get(dev, NULL, 0, 0, optional);
 586         if (IS_ERR(rstc))
 587                 return PTR_ERR(rstc);
 588
 589         ret = reset_control_reset(rstc);
 590
 591         reset_control_put(rstc);
 592
 593         return ret;
 594 }
 595 EXPORT_SYMBOL_GPL(__device_reset);
 596
 597 /**
 598  * APIs to manage an array of reset controls.
 599  */
 600 /**
 601  * of_reset_control_get_count - Count number of resets available with a device
 602  *
 603  * @node: device node that contains 'resets'.
 604  *
 605  * Returns positive reset count on success, or error number on failure and
 606  * on count being zero.
 607  */
 608 static int of_reset_control_get_count(struct device_node *node)
 609 {
 610         int count;
 611
 612         if (!node)
 613                 return -EINVAL;
 614
 615         count = of_count_phandle_with_args(node, "resets", "#reset-cells");
 616         if (count == 0)
 617                 count = -ENOENT;
 618
 619         return count;
 620 }
 621
 622 /**
 623  * of_reset_control_array_get - Get a list of reset controls using
 624  *                              device node.
 625  *
 626  * @np: device node for the device that requests the reset controls array
 627  * @shared: whether reset controls are shared or not
 628  * @optional: whether it is optional to get the reset controls
 629  *
 630  * Returns pointer to allocated reset_control_array on success or
 631  * error on failure
 632  */
 633 struct reset_control *
 634 of_reset_control_array_get(struct device_node *np, bool shared, bool optional)
 635 {
 636         struct reset_control_array *resets;
 637         struct reset_control *rstc;
 638         int num, i;
 639
 640         num = of_reset_control_get_count(np);
 641         if (num < 0)
 642                 return optional ? NULL : ERR_PTR(num);
 643
 644         resets = kzalloc(sizeof(*resets) + sizeof(resets->rstc[0]) * num,
 645                          GFP_KERNEL);
 646         if (!resets)
 647                 return ERR_PTR(-ENOMEM);
 648
 649         for (i = 0; i < num; i++) {
 650                 rstc = __of_reset_control_get(np, NULL, i, shared, optional);
 651                 if (IS_ERR(rstc))
 652                         goto err_rst;
 653                 resets->rstc[i] = rstc;
 654         }
 655         resets->num_rstcs = num;
 656         resets->base.array = true;
 657
 658         return &resets->base;
 659
 660 err_rst:
 661         mutex_lock(&reset_list_mutex);
 662         while (--i >= 0)
 663                 __reset_control_put_internal(resets->rstc[i]);
 664         mutex_unlock(&reset_list_mutex);
 665
 666         kfree(resets);
 667
 668         return rstc;
 669 }
 670 EXPORT_SYMBOL_GPL(of_reset_control_array_get);
 671
 672 /**
 673  * devm_reset_control_array_get - Resource managed reset control array get
 674  *
 675  * @dev: device that requests the list of reset controls
 676  * @shared: whether reset controls are shared or not
 677  * @optional: whether it is optional to get the reset controls
 678  *
 679  * The reset control array APIs are intended for a list of resets
 680  * that just have to be asserted or deasserted, without any
 681  * requirements on the order.
 682  *
 683  * Returns pointer to allocated reset_control_array on success or
 684  * error on failure
 685  */
 686 struct reset_control *
 687 devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
 688 {
 689         struct reset_control **devres;
 690         struct reset_control *rstc;
 691
 692         devres = devres_alloc(devm_reset_control_release, sizeof(*devres),
 693                               GFP_KERNEL);
 694         if (!devres)
 695                 return ERR_PTR(-ENOMEM);
 696
 697         rstc = of_reset_control_array_get(dev->of_node, shared, optional);
 698         if (IS_ERR(rstc)) {
 699                 devres_free(devres);
 700                 return rstc;
 701         }
 702
 703         *devres = rstc;
 704         devres_add(dev, devres);
 705
 706         return rstc;
 707 }
 708 EXPORT_SYMBOL_GPL(devm_reset_control_array_get);