drivers/reset/reset-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2016, NVIDIA CORPORATION.
   4  */
   5
   6 #include <common.h>
   7 #include <dm.h>
   8 #include <fdtdec.h>
   9 #include <log.h>
  10 #include <malloc.h>
  11 #include <reset.h>
  12 #include <reset-uclass.h>
  13 #include <dm/devres.h>
  14 #include <dm/lists.h>
  15
  16 static inline struct reset_ops *reset_dev_ops(struct udevice *dev)
  17 {
  18         return (struct reset_ops *)dev->driver->ops;
  19 }
  20
  21 static int reset_of_xlate_default(struct reset_ctl *reset_ctl,
  22                                   struct ofnode_phandle_args *args)
  23 {
  24         debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
  25
  26         if (args->args_count != 1) {
  27                 debug("Invaild args_count: %d\n", args->args_count);
  28                 return -EINVAL;
  29         }
  30
  31         reset_ctl->id = args->args[0];
  32
  33         return 0;
  34 }
  35
  36 static int reset_get_by_index_tail(int ret, ofnode node,
  37                                    struct ofnode_phandle_args *args,
  38                                    const char *list_name, int index,
  39                                    struct reset_ctl *reset_ctl)
  40 {
  41         struct udevice *dev_reset;
  42         struct reset_ops *ops;
  43
  44         assert(reset_ctl);
  45         reset_ctl->dev = NULL;
  46         if (ret)
  47                 return ret;
  48
  49         ret = uclass_get_device_by_ofnode(UCLASS_RESET, args->node,
  50                                           &dev_reset);
  51         if (ret) {
  52                 debug("%s: uclass_get_device_by_ofnode() failed: %d\n",
  53                       __func__, ret);
  54                 debug("%s %d\n", ofnode_get_name(args->node), args->args[0]);
  55                 return ret;
  56         }
  57         ops = reset_dev_ops(dev_reset);
  58
  59         reset_ctl->dev = dev_reset;
  60         if (ops->of_xlate)
  61                 ret = ops->of_xlate(reset_ctl, args);
  62         else
  63                 ret = reset_of_xlate_default(reset_ctl, args);
  64         if (ret) {
  65                 debug("of_xlate() failed: %d\n", ret);
  66                 return ret;
  67         }
  68
  69         ret = ops->request(reset_ctl);
  70         if (ret) {
  71                 debug("ops->request() failed: %d\n", ret);
  72                 return ret;
  73         }
  74
  75         return 0;
  76 }
  77
  78 int reset_get_by_index(struct udevice *dev, int index,
  79                        struct reset_ctl *reset_ctl)
  80 {
  81         struct ofnode_phandle_args args;
  82         int ret;
  83
  84         ret = dev_read_phandle_with_args(dev, "resets", "#reset-cells", 0,
  85                                          index, &args);
  86
  87         return reset_get_by_index_tail(ret, dev_ofnode(dev), &args, "resets",
  88                                        index > 0, reset_ctl);
  89 }
  90
  91 int reset_get_by_index_nodev(ofnode node, int index,
  92                              struct reset_ctl *reset_ctl)
  93 {
  94         struct ofnode_phandle_args args;
  95         int ret;
  96
  97         ret = ofnode_parse_phandle_with_args(node, "resets", "#reset-cells", 0,
  98                                              index > 0, &args);
  99
 100         return reset_get_by_index_tail(ret, node, &args, "resets",
 101                                        index > 0, reset_ctl);
 102 }
 103
 104 static int __reset_get_bulk(struct udevice *dev, ofnode node,
 105                             struct reset_ctl_bulk *bulk)
 106 {
 107         int i, ret, err, count;
 108
 109         bulk->count = 0;
 110
 111         count = ofnode_count_phandle_with_args(node, "resets", "#reset-cells",
 112                                                0);
 113         if (count < 1)
 114                 return count;
 115
 116         bulk->resets = devm_kcalloc(dev, count, sizeof(struct reset_ctl),
 117                                     GFP_KERNEL);
 118         if (!bulk->resets)
 119                 return -ENOMEM;
 120
 121         for (i = 0; i < count; i++) {
 122                 ret = reset_get_by_index_nodev(node, i, &bulk->resets[i]);
 123                 if (ret < 0)
 124                         goto bulk_get_err;
 125
 126                 ++bulk->count;
 127         }
 128
 129         return 0;
 130
 131 bulk_get_err:
 132         err = reset_release_all(bulk->resets, bulk->count);
 133         if (err)
 134                 debug("%s: could release all resets for %p\n",
 135                       __func__, dev);
 136
 137         return ret;
 138 }
 139
 140 int reset_get_bulk(struct udevice *dev, struct reset_ctl_bulk *bulk)
 141 {
 142         return __reset_get_bulk(dev, dev_ofnode(dev), bulk);
 143 }
 144
 145 int reset_get_by_name(struct udevice *dev, const char *name,
 146                      struct reset_ctl *reset_ctl)
 147 {
 148         int index;
 149
 150         debug("%s(dev=%p, name=%s, reset_ctl=%p)\n", __func__, dev, name,
 151               reset_ctl);
 152         reset_ctl->dev = NULL;
 153
 154         index = dev_read_stringlist_search(dev, "reset-names", name);
 155         if (index < 0) {
 156                 debug("fdt_stringlist_search() failed: %d\n", index);
 157                 return index;
 158         }
 159
 160         return reset_get_by_index(dev, index, reset_ctl);
 161 }
 162
 163 int reset_request(struct reset_ctl *reset_ctl)
 164 {
 165         struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
 166
 167         debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
 168
 169         return ops->request(reset_ctl);
 170 }
 171
 172 int reset_free(struct reset_ctl *reset_ctl)
 173 {
 174         struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
 175
 176         debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
 177
 178         return ops->rfree(reset_ctl);
 179 }
 180
 181 int reset_assert(struct reset_ctl *reset_ctl)
 182 {
 183         struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
 184
 185         debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
 186
 187         return ops->rst_assert(reset_ctl);
 188 }
 189
 190 int reset_assert_bulk(struct reset_ctl_bulk *bulk)
 191 {
 192         int i, ret;
 193
 194         for (i = 0; i < bulk->count; i++) {
 195                 ret = reset_assert(&bulk->resets[i]);
 196                 if (ret < 0)
 197                         return ret;
 198         }
 199
 200         return 0;
 201 }
 202
 203 int reset_deassert(struct reset_ctl *reset_ctl)
 204 {
 205         struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
 206
 207         debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
 208
 209         return ops->rst_deassert(reset_ctl);
 210 }
 211
 212 int reset_deassert_bulk(struct reset_ctl_bulk *bulk)
 213 {
 214         int i, ret;
 215
 216         for (i = 0; i < bulk->count; i++) {
 217                 ret = reset_deassert(&bulk->resets[i]);
 218                 if (ret < 0)
 219                         return ret;
 220         }
 221
 222         return 0;
 223 }
 224
 225 int reset_status(struct reset_ctl *reset_ctl)
 226 {
 227         struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
 228
 229         debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
 230
 231         return ops->rst_status(reset_ctl);
 232 }
 233
 234 int reset_release_all(struct reset_ctl *reset_ctl, int count)
 235 {
 236         int i, ret;
 237
 238         for (i = 0; i < count; i++) {
 239                 debug("%s(reset_ctl[%d]=%p)\n", __func__, i, &reset_ctl[i]);
 240
 241                 /* check if reset has been previously requested */
 242                 if (!reset_ctl[i].dev)
 243                         continue;
 244
 245                 ret = reset_assert(&reset_ctl[i]);
 246                 if (ret)
 247                         return ret;
 248
 249                 ret = reset_free(&reset_ctl[i]);
 250                 if (ret)
 251                         return ret;
 252         }
 253
 254         return 0;
 255 }
 256
 257 static void devm_reset_release(struct udevice *dev, void *res)
 258 {
 259         reset_free(res);
 260 }
 261
 262 struct reset_ctl *devm_reset_control_get_by_index(struct udevice *dev,
 263                                                   int index)
 264 {
 265         int rc;
 266         struct reset_ctl *reset_ctl;
 267
 268         reset_ctl = devres_alloc(devm_reset_release, sizeof(struct reset_ctl),
 269                                  __GFP_ZERO);
 270         if (unlikely(!reset_ctl))
 271                 return ERR_PTR(-ENOMEM);
 272
 273         rc = reset_get_by_index(dev, index, reset_ctl);
 274         if (rc)
 275                 return ERR_PTR(rc);
 276
 277         devres_add(dev, reset_ctl);
 278         return reset_ctl;
 279 }
 280
 281 struct reset_ctl *devm_reset_control_get(struct udevice *dev, const char *id)
 282 {
 283         int rc;
 284         struct reset_ctl *reset_ctl;
 285
 286         reset_ctl = devres_alloc(devm_reset_release, sizeof(struct reset_ctl),
 287                                  __GFP_ZERO);
 288         if (unlikely(!reset_ctl))
 289                 return ERR_PTR(-ENOMEM);
 290
 291         rc = reset_get_by_name(dev, id, reset_ctl);
 292         if (rc)
 293                 return ERR_PTR(rc);
 294
 295         devres_add(dev, reset_ctl);
 296         return reset_ctl;
 297 }
 298
 299 struct reset_ctl *devm_reset_control_get_optional(struct udevice *dev,
 300                                                   const char *id)
 301 {
 302         struct reset_ctl *r = devm_reset_control_get(dev, id);
 303
 304         if (IS_ERR(r))
 305                 return NULL;
 306
 307         return r;
 308 }
 309
 310 static void devm_reset_bulk_release(struct udevice *dev, void *res)
 311 {
 312         struct reset_ctl_bulk *bulk = res;
 313
 314         reset_release_all(bulk->resets, bulk->count);
 315 }
 316
 317 struct reset_ctl_bulk *devm_reset_bulk_get_by_node(struct udevice *dev,
 318                                                    ofnode node)
 319 {
 320         int rc;
 321         struct reset_ctl_bulk *bulk;
 322
 323         bulk = devres_alloc(devm_reset_bulk_release,
 324                             sizeof(struct reset_ctl_bulk),
 325                             __GFP_ZERO);
 326         if (unlikely(!bulk))
 327                 return ERR_PTR(-ENOMEM);
 328
 329         rc = __reset_get_bulk(dev, node, bulk);
 330         if (rc)
 331                 return ERR_PTR(rc);
 332
 333         devres_add(dev, bulk);
 334         return bulk;
 335 }
 336
 337 struct reset_ctl_bulk *devm_reset_bulk_get_optional_by_node(struct udevice *dev,
 338                                                             ofnode node)
 339 {
 340         struct reset_ctl_bulk *bulk;
 341
 342         bulk = devm_reset_bulk_get_by_node(dev, node);
 343
 344         if (IS_ERR(bulk))
 345                 return NULL;
 346
 347         return bulk;
 348 }
 349
 350 struct reset_ctl_bulk *devm_reset_bulk_get(struct udevice *dev)
 351 {
 352         return devm_reset_bulk_get_by_node(dev, dev_ofnode(dev));
 353 }
 354
 355 struct reset_ctl_bulk *devm_reset_bulk_get_optional(struct udevice *dev)
 356 {
 357         return devm_reset_bulk_get_optional_by_node(dev, dev_ofnode(dev));
 358 }
 359
 360 UCLASS_DRIVER(reset) = {
 361         .id             = UCLASS_RESET,
 362         .name           = "reset",
 363 };