git.sur5r.net Git - u-boot/blob - drivers/reset/reset-uclass.c

   1 /*
   2  * Copyright (c) 2016, NVIDIA CORPORATION.
   3  *
   4  * SPDX-License-Identifier: GPL-2.0
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <fdtdec.h>
  10 #include <reset.h>
  11 #include <reset-uclass.h>
  12
  13 DECLARE_GLOBAL_DATA_PTR;
  14
  15 static inline struct reset_ops *reset_dev_ops(struct udevice *dev)
  16 {
  17         return (struct reset_ops *)dev->driver->ops;
  18 }
  19
  20 static int reset_of_xlate_default(struct reset_ctl *reset_ctl,
  21                                   struct ofnode_phandle_args *args)
  22 {
  23         debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
  24
  25         if (args->args_count != 1) {
  26                 debug("Invaild args_count: %d\n", args->args_count);
  27                 return -EINVAL;
  28         }
  29
  30         reset_ctl->id = args->args[0];
  31
  32         return 0;
  33 }
  34
  35 int reset_get_by_index(struct udevice *dev, int index,
  36                        struct reset_ctl *reset_ctl)
  37 {
  38         struct ofnode_phandle_args args;
  39         int ret;
  40         struct udevice *dev_reset;
  41         struct reset_ops *ops;
  42
  43         debug("%s(dev=%p, index=%d, reset_ctl=%p)\n", __func__, dev, index,
  44               reset_ctl);
  45         reset_ctl->dev = NULL;
  46
  47         ret = dev_read_phandle_with_args(dev, "resets", "#reset-cells", 0,
  48                                           index, &args);
  49         if (ret) {
  50                 debug("%s: fdtdec_parse_phandle_with_args() failed: %d\n",
  51                       __func__, ret);
  52                 return ret;
  53         }
  54
  55         ret = uclass_get_device_by_ofnode(UCLASS_RESET, args.node,
  56                                           &dev_reset);
  57         if (ret) {
  58                 debug("%s: uclass_get_device_by_ofnode() failed: %d\n",
  59                       __func__, ret);
  60                 debug("%s %d\n", ofnode_get_name(args.node), args.args[0]);
  61                 return ret;
  62         }
  63         ops = reset_dev_ops(dev_reset);
  64
  65         reset_ctl->dev = dev_reset;
  66         if (ops->of_xlate)
  67                 ret = ops->of_xlate(reset_ctl, &args);
  68         else
  69                 ret = reset_of_xlate_default(reset_ctl, &args);
  70         if (ret) {
  71                 debug("of_xlate() failed: %d\n", ret);
  72                 return ret;
  73         }
  74
  75         ret = ops->request(reset_ctl);
  76         if (ret) {
  77                 debug("ops->request() failed: %d\n", ret);
  78                 return ret;
  79         }
  80
  81         return 0;
  82 }
  83
  84 int reset_get_bulk(struct udevice *dev, struct reset_ctl_bulk *bulk)
  85 {
  86         int i, ret, err, count;
  87
  88         bulk->count = 0;
  89
  90         count = dev_count_phandle_with_args(dev, "resets", "#reset-cells");
  91         if (!count)
  92                 return 0;
  93
  94         bulk->resets = devm_kcalloc(dev, count, sizeof(struct reset_ctl),
  95                                     GFP_KERNEL);
  96         if (!bulk->resets)
  97                 return -ENOMEM;
  98
  99         for (i = 0; i < count; i++) {
 100                 ret = reset_get_by_index(dev, i, &bulk->resets[i]);
 101                 if (ret < 0)
 102                         goto bulk_get_err;
 103
 104                 ++bulk->count;
 105         }
 106
 107         return 0;
 108
 109 bulk_get_err:
 110         err = reset_release_all(bulk->resets, bulk->count);
 111         if (err)
 112                 debug("%s: could release all resets for %p\n",
 113                       __func__, dev);
 114
 115         return ret;
 116 }
 117
 118 int reset_get_by_name(struct udevice *dev, const char *name,
 119                      struct reset_ctl *reset_ctl)
 120 {
 121         int index;
 122
 123         debug("%s(dev=%p, name=%s, reset_ctl=%p)\n", __func__, dev, name,
 124               reset_ctl);
 125         reset_ctl->dev = NULL;
 126
 127         index = dev_read_stringlist_search(dev, "reset-names", name);
 128         if (index < 0) {
 129                 debug("fdt_stringlist_search() failed: %d\n", index);
 130                 return index;
 131         }
 132
 133         return reset_get_by_index(dev, index, reset_ctl);
 134 }
 135
 136 int reset_request(struct reset_ctl *reset_ctl)
 137 {
 138         struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
 139
 140         debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
 141
 142         return ops->request(reset_ctl);
 143 }
 144
 145 int reset_free(struct reset_ctl *reset_ctl)
 146 {
 147         struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
 148
 149         debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
 150
 151         return ops->free(reset_ctl);
 152 }
 153
 154 int reset_assert(struct reset_ctl *reset_ctl)
 155 {
 156         struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
 157
 158         debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
 159
 160         return ops->rst_assert(reset_ctl);
 161 }
 162
 163 int reset_assert_bulk(struct reset_ctl_bulk *bulk)
 164 {
 165         int i, ret;
 166
 167         for (i = 0; i < bulk->count; i++) {
 168                 ret = reset_assert(&bulk->resets[i]);
 169                 if (ret < 0)
 170                         return ret;
 171         }
 172
 173         return 0;
 174 }
 175
 176 int reset_deassert(struct reset_ctl *reset_ctl)
 177 {
 178         struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
 179
 180         debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
 181
 182         return ops->rst_deassert(reset_ctl);
 183 }
 184
 185 int reset_deassert_bulk(struct reset_ctl_bulk *bulk)
 186 {
 187         int i, ret;
 188
 189         for (i = 0; i < bulk->count; i++) {
 190                 ret = reset_deassert(&bulk->resets[i]);
 191                 if (ret < 0)
 192                         return ret;
 193         }
 194
 195         return 0;
 196 }
 197
 198 int reset_release_all(struct reset_ctl *reset_ctl, int count)
 199 {
 200         int i, ret;
 201
 202         for (i = 0; i < count; i++) {
 203                 debug("%s(reset_ctl[%d]=%p)\n", __func__, i, &reset_ctl[i]);
 204
 205                 /* check if reset has been previously requested */
 206                 if (!reset_ctl[i].dev)
 207                         continue;
 208
 209                 ret = reset_assert(&reset_ctl[i]);
 210                 if (ret)
 211                         return ret;
 212
 213                 ret = reset_free(&reset_ctl[i]);
 214                 if (ret)
 215                         return ret;
 216         }
 217
 218         return 0;
 219 }
 220
 221 UCLASS_DRIVER(reset) = {
 222         .id             = UCLASS_RESET,
 223         .name           = "reset",
 224 };