drivers/clk/clk-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2015 Google, Inc
   4  * Written by Simon Glass <sjg@chromium.org>
   5  * Copyright (c) 2016, NVIDIA CORPORATION.
   6  * Copyright (c) 2018, Theobroma Systems Design und Consulting GmbH
   7  */
   8
   9 #include <common.h>
  10 #include <clk.h>
  11 #include <clk-uclass.h>
  12 #include <dm.h>
  13 #include <dt-structs.h>
  14 #include <errno.h>
  15 #include <log.h>
  16 #include <malloc.h>
  17 #include <dm/device-internal.h>
  18 #include <dm/devres.h>
  19 #include <dm/read.h>
  20 #include <linux/bug.h>
  21 #include <linux/clk-provider.h>
  22 #include <linux/err.h>
  23
  24 static inline const struct clk_ops *clk_dev_ops(struct udevice *dev)
  25 {
  26         return (const struct clk_ops *)dev->driver->ops;
  27 }
  28
  29 struct clk *dev_get_clk_ptr(struct udevice *dev)
  30 {
  31         return (struct clk *)dev_get_uclass_priv(dev);
  32 }
  33
  34 #if CONFIG_IS_ENABLED(OF_CONTROL)
  35 # if CONFIG_IS_ENABLED(OF_PLATDATA)
  36 int clk_get_by_driver_info(struct udevice *dev, struct phandle_1_arg *cells,
  37                            struct clk *clk)
  38 {
  39         int ret;
  40
  41         ret = device_get_by_driver_info_idx(cells->idx, &clk->dev);
  42         if (ret)
  43                 return ret;
  44         clk->id = cells->arg[0];
  45
  46         return 0;
  47 }
  48 # else
  49 static int clk_of_xlate_default(struct clk *clk,
  50                                 struct ofnode_phandle_args *args)
  51 {
  52         debug("%s(clk=%p)\n", __func__, clk);
  53
  54         if (args->args_count > 1) {
  55                 debug("Invaild args_count: %d\n", args->args_count);
  56                 return -EINVAL;
  57         }
  58
  59         if (args->args_count)
  60                 clk->id = args->args[0];
  61         else
  62                 clk->id = 0;
  63
  64         clk->data = 0;
  65
  66         return 0;
  67 }
  68
  69 static int clk_get_by_index_tail(int ret, ofnode node,
  70                                  struct ofnode_phandle_args *args,
  71                                  const char *list_name, int index,
  72                                  struct clk *clk)
  73 {
  74         struct udevice *dev_clk;
  75         const struct clk_ops *ops;
  76
  77         assert(clk);
  78         clk->dev = NULL;
  79         if (ret)
  80                 goto err;
  81
  82         ret = uclass_get_device_by_ofnode(UCLASS_CLK, args->node, &dev_clk);
  83         if (ret) {
  84                 debug("%s: uclass_get_device_by_of_offset failed: err=%d\n",
  85                       __func__, ret);
  86                 return log_msg_ret("get", ret);
  87         }
  88
  89         clk->dev = dev_clk;
  90
  91         ops = clk_dev_ops(dev_clk);
  92
  93         if (ops->of_xlate)
  94                 ret = ops->of_xlate(clk, args);
  95         else
  96                 ret = clk_of_xlate_default(clk, args);
  97         if (ret) {
  98                 debug("of_xlate() failed: %d\n", ret);
  99                 return log_msg_ret("xlate", ret);
 100         }
 101
 102         return clk_request(dev_clk, clk);
 103 err:
 104         debug("%s: Node '%s', property '%s', failed to request CLK index %d: %d\n",
 105               __func__, ofnode_get_name(node), list_name, index, ret);
 106
 107         return log_msg_ret("prop", ret);
 108 }
 109
 110 static int clk_get_by_indexed_prop(struct udevice *dev, const char *prop_name,
 111                                    int index, struct clk *clk)
 112 {
 113         int ret;
 114         struct ofnode_phandle_args args;
 115
 116         debug("%s(dev=%p, index=%d, clk=%p)\n", __func__, dev, index, clk);
 117
 118         assert(clk);
 119         clk->dev = NULL;
 120
 121         ret = dev_read_phandle_with_args(dev, prop_name, "#clock-cells", 0,
 122                                          index, &args);
 123         if (ret) {
 124                 debug("%s: fdtdec_parse_phandle_with_args failed: err=%d\n",
 125                       __func__, ret);
 126                 return log_ret(ret);
 127         }
 128
 129
 130         return clk_get_by_index_tail(ret, dev_ofnode(dev), &args, "clocks",
 131                                      index, clk);
 132 }
 133
 134 int clk_get_by_index(struct udevice *dev, int index, struct clk *clk)
 135 {
 136         struct ofnode_phandle_args args;
 137         int ret;
 138
 139         ret = dev_read_phandle_with_args(dev, "clocks", "#clock-cells", 0,
 140                                          index, &args);
 141
 142         return clk_get_by_index_tail(ret, dev_ofnode(dev), &args, "clocks",
 143                                      index, clk);
 144 }
 145
 146 int clk_get_by_index_nodev(ofnode node, int index, struct clk *clk)
 147 {
 148         struct ofnode_phandle_args args;
 149         int ret;
 150
 151         ret = ofnode_parse_phandle_with_args(node, "clocks", "#clock-cells", 0,
 152                                              index, &args);
 153
 154         return clk_get_by_index_tail(ret, node, &args, "clocks",
 155                                      index, clk);
 156 }
 157
 158 int clk_get_bulk(struct udevice *dev, struct clk_bulk *bulk)
 159 {
 160         int i, ret, err, count;
 161
 162         bulk->count = 0;
 163
 164         count = dev_count_phandle_with_args(dev, "clocks", "#clock-cells", 0);
 165         if (count < 1)
 166                 return count;
 167
 168         bulk->clks = devm_kcalloc(dev, count, sizeof(struct clk), GFP_KERNEL);
 169         if (!bulk->clks)
 170                 return -ENOMEM;
 171
 172         for (i = 0; i < count; i++) {
 173                 ret = clk_get_by_index(dev, i, &bulk->clks[i]);
 174                 if (ret < 0)
 175                         goto bulk_get_err;
 176
 177                 ++bulk->count;
 178         }
 179
 180         return 0;
 181
 182 bulk_get_err:
 183         err = clk_release_all(bulk->clks, bulk->count);
 184         if (err)
 185                 debug("%s: could release all clocks for %p\n",
 186                       __func__, dev);
 187
 188         return ret;
 189 }
 190
 191 static struct clk *clk_set_default_get_by_id(struct clk *clk)
 192 {
 193         struct clk *c = clk;
 194
 195         if (CONFIG_IS_ENABLED(CLK_CCF)) {
 196                 int ret = clk_get_by_id(clk->id, &c);
 197
 198                 if (ret) {
 199                         debug("%s(): could not get parent clock pointer, id %lu\n",
 200                               __func__, clk->id);
 201                         ERR_PTR(ret);
 202                 }
 203         }
 204
 205         return c;
 206 }
 207
 208 static int clk_set_default_parents(struct udevice *dev, int stage)
 209 {
 210         struct clk clk, parent_clk, *c, *p;
 211         int index;
 212         int num_parents;
 213         int ret;
 214
 215         num_parents = dev_count_phandle_with_args(dev, "assigned-clock-parents",
 216                                                   "#clock-cells", 0);
 217         if (num_parents < 0) {
 218                 debug("%s: could not read assigned-clock-parents for %p\n",
 219                       __func__, dev);
 220                 return 0;
 221         }
 222
 223         for (index = 0; index < num_parents; index++) {
 224                 ret = clk_get_by_indexed_prop(dev, "assigned-clock-parents",
 225                                               index, &parent_clk);
 226                 /* If -ENOENT, this is a no-op entry */
 227                 if (ret == -ENOENT)
 228                         continue;
 229
 230                 if (ret) {
 231                         debug("%s: could not get parent clock %d for %s\n",
 232                               __func__, index, dev_read_name(dev));
 233                         return ret;
 234                 }
 235
 236                 p = clk_set_default_get_by_id(&parent_clk);
 237                 if (IS_ERR(p))
 238                         return PTR_ERR(p);
 239
 240                 ret = clk_get_by_indexed_prop(dev, "assigned-clocks",
 241                                               index, &clk);
 242                 if (ret) {
 243                         debug("%s: could not get assigned clock %d for %s\n",
 244                               __func__, index, dev_read_name(dev));
 245                         return ret;
 246                 }
 247
 248                 /* This is clk provider device trying to reparent itself
 249                  * It cannot be done right now but need to wait after the
 250                  * device is probed
 251                  */
 252                 if (stage == 0 && clk.dev == dev)
 253                         continue;
 254
 255                 if (stage > 0 && clk.dev != dev)
 256                         /* do not setup twice the parent clocks */
 257                         continue;
 258
 259                 c = clk_set_default_get_by_id(&clk);
 260                 if (IS_ERR(c))
 261                         return PTR_ERR(c);
 262
 263                 ret = clk_set_parent(c, p);
 264                 /*
 265                  * Not all drivers may support clock-reparenting (as of now).
 266                  * Ignore errors due to this.
 267                  */
 268                 if (ret == -ENOSYS)
 269                         continue;
 270
 271                 if (ret < 0) {
 272                         debug("%s: failed to reparent clock %d for %s\n",
 273                               __func__, index, dev_read_name(dev));
 274                         return ret;
 275                 }
 276         }
 277
 278         return 0;
 279 }
 280
 281 static int clk_set_default_rates(struct udevice *dev, int stage)
 282 {
 283         struct clk clk, *c;
 284         int index;
 285         int num_rates;
 286         int size;
 287         int ret = 0;
 288         u32 *rates = NULL;
 289
 290         size = dev_read_size(dev, "assigned-clock-rates");
 291         if (size < 0)
 292                 return 0;
 293
 294         num_rates = size / sizeof(u32);
 295         rates = calloc(num_rates, sizeof(u32));
 296         if (!rates)
 297                 return -ENOMEM;
 298
 299         ret = dev_read_u32_array(dev, "assigned-clock-rates", rates, num_rates);
 300         if (ret)
 301                 goto fail;
 302
 303         for (index = 0; index < num_rates; index++) {
 304                 /* If 0 is passed, this is a no-op */
 305                 if (!rates[index])
 306                         continue;
 307
 308                 ret = clk_get_by_indexed_prop(dev, "assigned-clocks",
 309                                               index, &clk);
 310                 if (ret) {
 311                         debug("%s: could not get assigned clock %d for %s\n",
 312                               __func__, index, dev_read_name(dev));
 313                         continue;
 314                 }
 315
 316                 /* This is clk provider device trying to program itself
 317                  * It cannot be done right now but need to wait after the
 318                  * device is probed
 319                  */
 320                 if (stage == 0 && clk.dev == dev)
 321                         continue;
 322
 323                 if (stage > 0 && clk.dev != dev)
 324                         /* do not setup twice the parent clocks */
 325                         continue;
 326
 327                 c = clk_set_default_get_by_id(&clk);
 328                 if (IS_ERR(c))
 329                         return PTR_ERR(c);
 330
 331                 ret = clk_set_rate(c, rates[index]);
 332
 333                 if (ret < 0) {
 334                         debug("%s: failed to set rate on clock index %d (%ld) for %s\n",
 335                               __func__, index, clk.id, dev_read_name(dev));
 336                         break;
 337                 }
 338         }
 339
 340 fail:
 341         free(rates);
 342         return ret;
 343 }
 344
 345 int clk_set_defaults(struct udevice *dev, int stage)
 346 {
 347         int ret;
 348
 349         if (!dev_has_ofnode(dev))
 350                 return 0;
 351
 352         /* If this not in SPL and pre-reloc state, don't take any action. */
 353         if (!(IS_ENABLED(CONFIG_SPL_BUILD) || (gd->flags & GD_FLG_RELOC)))
 354                 return 0;
 355
 356         debug("%s(%s)\n", __func__, dev_read_name(dev));
 357
 358         ret = clk_set_default_parents(dev, stage);
 359         if (ret)
 360                 return ret;
 361
 362         ret = clk_set_default_rates(dev, stage);
 363         if (ret < 0)
 364                 return ret;
 365
 366         return 0;
 367 }
 368
 369 int clk_get_by_name(struct udevice *dev, const char *name, struct clk *clk)
 370 {
 371         int index;
 372
 373         debug("%s(dev=%p, name=%s, clk=%p)\n", __func__, dev, name, clk);
 374         clk->dev = NULL;
 375
 376         index = dev_read_stringlist_search(dev, "clock-names", name);
 377         if (index < 0) {
 378                 debug("fdt_stringlist_search() failed: %d\n", index);
 379                 return index;
 380         }
 381
 382         return clk_get_by_index(dev, index, clk);
 383 }
 384 # endif /* OF_PLATDATA */
 385
 386 int clk_get_by_name_nodev(ofnode node, const char *name, struct clk *clk)
 387 {
 388         int index;
 389
 390         debug("%s(node=%p, name=%s, clk=%p)\n", __func__,
 391                 ofnode_get_name(node), name, clk);
 392         clk->dev = NULL;
 393
 394         index = ofnode_stringlist_search(node, "clock-names", name);
 395         if (index < 0) {
 396                 debug("fdt_stringlist_search() failed: %d\n", index);
 397                 return index;
 398         }
 399
 400         return clk_get_by_index_nodev(node, index, clk);
 401 }
 402
 403 int clk_get_optional_nodev(ofnode node, const char *name, struct clk *clk)
 404 {
 405         int ret;
 406
 407         ret = clk_get_by_name_nodev(node, name, clk);
 408         if (ret == -ENODATA)
 409                 return 0;
 410
 411         return ret;
 412 }
 413
 414 int clk_release_all(struct clk *clk, int count)
 415 {
 416         int i, ret;
 417
 418         for (i = 0; i < count; i++) {
 419                 debug("%s(clk[%d]=%p)\n", __func__, i, &clk[i]);
 420
 421                 /* check if clock has been previously requested */
 422                 if (!clk[i].dev)
 423                         continue;
 424
 425                 ret = clk_disable(&clk[i]);
 426                 if (ret && ret != -ENOSYS)
 427                         return ret;
 428
 429                 ret = clk_free(&clk[i]);
 430                 if (ret && ret != -ENOSYS)
 431                         return ret;
 432         }
 433
 434         return 0;
 435 }
 436
 437 #endif /* OF_CONTROL */
 438
 439 int clk_request(struct udevice *dev, struct clk *clk)
 440 {
 441         const struct clk_ops *ops;
 442
 443         debug("%s(dev=%p, clk=%p)\n", __func__, dev, clk);
 444         if (!clk)
 445                 return 0;
 446         ops = clk_dev_ops(dev);
 447
 448         clk->dev = dev;
 449
 450         if (!ops->request)
 451                 return 0;
 452
 453         return ops->request(clk);
 454 }
 455
 456 int clk_free(struct clk *clk)
 457 {
 458         const struct clk_ops *ops;
 459
 460         debug("%s(clk=%p)\n", __func__, clk);
 461         if (!clk_valid(clk))
 462                 return 0;
 463         ops = clk_dev_ops(clk->dev);
 464
 465         if (!ops->rfree)
 466                 return 0;
 467
 468         return ops->rfree(clk);
 469 }
 470
 471 ulong clk_get_rate(struct clk *clk)
 472 {
 473         const struct clk_ops *ops;
 474         int ret;
 475
 476         debug("%s(clk=%p)\n", __func__, clk);
 477         if (!clk_valid(clk))
 478                 return 0;
 479         ops = clk_dev_ops(clk->dev);
 480
 481         if (!ops->get_rate)
 482                 return -ENOSYS;
 483
 484         ret = ops->get_rate(clk);
 485         if (ret)
 486                 return log_ret(ret);
 487
 488         return 0;
 489 }
 490
 491 struct clk *clk_get_parent(struct clk *clk)
 492 {
 493         struct udevice *pdev;
 494         struct clk *pclk;
 495
 496         debug("%s(clk=%p)\n", __func__, clk);
 497         if (!clk_valid(clk))
 498                 return NULL;
 499
 500         pdev = dev_get_parent(clk->dev);
 501         pclk = dev_get_clk_ptr(pdev);
 502         if (!pclk)
 503                 return ERR_PTR(-ENODEV);
 504
 505         return pclk;
 506 }
 507
 508 long long clk_get_parent_rate(struct clk *clk)
 509 {
 510         const struct clk_ops *ops;
 511         struct clk *pclk;
 512
 513         debug("%s(clk=%p)\n", __func__, clk);
 514         if (!clk_valid(clk))
 515                 return 0;
 516
 517         pclk = clk_get_parent(clk);
 518         if (IS_ERR(pclk))
 519                 return -ENODEV;
 520
 521         ops = clk_dev_ops(pclk->dev);
 522         if (!ops->get_rate)
 523                 return -ENOSYS;
 524
 525         /* Read the 'rate' if not already set or if proper flag set*/
 526         if (!pclk->rate || pclk->flags & CLK_GET_RATE_NOCACHE)
 527                 pclk->rate = clk_get_rate(pclk);
 528
 529         return pclk->rate;
 530 }
 531
 532 ulong clk_round_rate(struct clk *clk, ulong rate)
 533 {
 534         const struct clk_ops *ops;
 535
 536         debug("%s(clk=%p, rate=%lu)\n", __func__, clk, rate);
 537         if (!clk_valid(clk))
 538                 return 0;
 539
 540         ops = clk_dev_ops(clk->dev);
 541         if (!ops->round_rate)
 542                 return -ENOSYS;
 543
 544         return ops->round_rate(clk, rate);
 545 }
 546
 547 ulong clk_set_rate(struct clk *clk, ulong rate)
 548 {
 549         const struct clk_ops *ops;
 550
 551         debug("%s(clk=%p, rate=%lu)\n", __func__, clk, rate);
 552         if (!clk_valid(clk))
 553                 return 0;
 554         ops = clk_dev_ops(clk->dev);
 555
 556         if (!ops->set_rate)
 557                 return -ENOSYS;
 558
 559         return ops->set_rate(clk, rate);
 560 }
 561
 562 int clk_set_parent(struct clk *clk, struct clk *parent)
 563 {
 564         const struct clk_ops *ops;
 565         int ret;
 566
 567         debug("%s(clk=%p, parent=%p)\n", __func__, clk, parent);
 568         if (!clk_valid(clk))
 569                 return 0;
 570         ops = clk_dev_ops(clk->dev);
 571
 572         if (!ops->set_parent)
 573                 return -ENOSYS;
 574
 575         ret = ops->set_parent(clk, parent);
 576         if (ret)
 577                 return ret;
 578
 579         if (CONFIG_IS_ENABLED(CLK_CCF))
 580                 ret = device_reparent(clk->dev, parent->dev);
 581
 582         return ret;
 583 }
 584
 585 int clk_enable(struct clk *clk)
 586 {
 587         const struct clk_ops *ops;
 588         struct clk *clkp = NULL;
 589         int ret;
 590
 591         debug("%s(clk=%p)\n", __func__, clk);
 592         if (!clk_valid(clk))
 593                 return 0;
 594         ops = clk_dev_ops(clk->dev);
 595
 596         if (CONFIG_IS_ENABLED(CLK_CCF)) {
 597                 /* Take id 0 as a non-valid clk, such as dummy */
 598                 if (clk->id && !clk_get_by_id(clk->id, &clkp)) {
 599                         if (clkp->enable_count) {
 600                                 clkp->enable_count++;
 601                                 return 0;
 602                         }
 603                         if (clkp->dev->parent &&
 604                             device_get_uclass_id(clkp->dev) == UCLASS_CLK) {
 605                                 ret = clk_enable(dev_get_clk_ptr(clkp->dev->parent));
 606                                 if (ret) {
 607                                         printf("Enable %s failed\n",
 608                                                clkp->dev->parent->name);
 609                                         return ret;
 610                                 }
 611                         }
 612                 }
 613
 614                 if (ops->enable) {
 615                         ret = ops->enable(clk);
 616                         if (ret) {
 617                                 printf("Enable %s failed\n", clk->dev->name);
 618                                 return ret;
 619                         }
 620                 }
 621                 if (clkp)
 622                         clkp->enable_count++;
 623         } else {
 624                 if (!ops->enable)
 625                         return -ENOSYS;
 626                 return ops->enable(clk);
 627         }
 628
 629         return 0;
 630 }
 631
 632 int clk_enable_bulk(struct clk_bulk *bulk)
 633 {
 634         int i, ret;
 635
 636         for (i = 0; i < bulk->count; i++) {
 637                 ret = clk_enable(&bulk->clks[i]);
 638                 if (ret < 0 && ret != -ENOSYS)
 639                         return ret;
 640         }
 641
 642         return 0;
 643 }
 644
 645 int clk_disable(struct clk *clk)
 646 {
 647         const struct clk_ops *ops;
 648         struct clk *clkp = NULL;
 649         int ret;
 650
 651         debug("%s(clk=%p)\n", __func__, clk);
 652         if (!clk_valid(clk))
 653                 return 0;
 654         ops = clk_dev_ops(clk->dev);
 655
 656         if (CONFIG_IS_ENABLED(CLK_CCF)) {
 657                 if (clk->id && !clk_get_by_id(clk->id, &clkp)) {
 658                         if (clkp->flags & CLK_IS_CRITICAL)
 659                                 return 0;
 660
 661                         if (clkp->enable_count == 0) {
 662                                 printf("clk %s already disabled\n",
 663                                        clkp->dev->name);
 664                                 return 0;
 665                         }
 666
 667                         if (--clkp->enable_count > 0)
 668                                 return 0;
 669                 }
 670
 671                 if (ops->disable) {
 672                         ret = ops->disable(clk);
 673                         if (ret)
 674                                 return ret;
 675                 }
 676
 677                 if (clkp && clkp->dev->parent &&
 678                     device_get_uclass_id(clkp->dev) == UCLASS_CLK) {
 679                         ret = clk_disable(dev_get_clk_ptr(clkp->dev->parent));
 680                         if (ret) {
 681                                 printf("Disable %s failed\n",
 682                                        clkp->dev->parent->name);
 683                                 return ret;
 684                         }
 685                 }
 686         } else {
 687                 if (!ops->disable)
 688                         return -ENOSYS;
 689
 690                 return ops->disable(clk);
 691         }
 692
 693         return 0;
 694 }
 695
 696 int clk_disable_bulk(struct clk_bulk *bulk)
 697 {
 698         int i, ret;
 699
 700         for (i = 0; i < bulk->count; i++) {
 701                 ret = clk_disable(&bulk->clks[i]);
 702                 if (ret < 0 && ret != -ENOSYS)
 703                         return ret;
 704         }
 705
 706         return 0;
 707 }
 708
 709 int clk_get_by_id(ulong id, struct clk **clkp)
 710 {
 711         struct udevice *dev;
 712         struct uclass *uc;
 713         int ret;
 714
 715         ret = uclass_get(UCLASS_CLK, &uc);
 716         if (ret)
 717                 return ret;
 718
 719         uclass_foreach_dev(dev, uc) {
 720                 struct clk *clk = dev_get_clk_ptr(dev);
 721
 722                 if (clk && clk->id == id) {
 723                         *clkp = clk;
 724                         return 0;
 725                 }
 726         }
 727
 728         return -ENOENT;
 729 }
 730
 731 bool clk_is_match(const struct clk *p, const struct clk *q)
 732 {
 733         /* trivial case: identical struct clk's or both NULL */
 734         if (p == q)
 735                 return true;
 736
 737         /* trivial case #2: on the clk pointer is NULL */
 738         if (!p || !q)
 739                 return false;
 740
 741         /* same device, id and data */
 742         if (p->dev == q->dev && p->id == q->id && p->data == q->data)
 743                 return true;
 744
 745         return false;
 746 }
 747
 748 static void devm_clk_release(struct udevice *dev, void *res)
 749 {
 750         clk_free(res);
 751 }
 752
 753 static int devm_clk_match(struct udevice *dev, void *res, void *data)
 754 {
 755         return res == data;
 756 }
 757
 758 struct clk *devm_clk_get(struct udevice *dev, const char *id)
 759 {
 760         int rc;
 761         struct clk *clk;
 762
 763         clk = devres_alloc(devm_clk_release, sizeof(struct clk), __GFP_ZERO);
 764         if (unlikely(!clk))
 765                 return ERR_PTR(-ENOMEM);
 766
 767         rc = clk_get_by_name(dev, id, clk);
 768         if (rc)
 769                 return ERR_PTR(rc);
 770
 771         devres_add(dev, clk);
 772         return clk;
 773 }
 774
 775 struct clk *devm_clk_get_optional(struct udevice *dev, const char *id)
 776 {
 777         struct clk *clk = devm_clk_get(dev, id);
 778
 779         if (PTR_ERR(clk) == -ENODATA)
 780                 return NULL;
 781
 782         return clk;
 783 }
 784
 785 void devm_clk_put(struct udevice *dev, struct clk *clk)
 786 {
 787         int rc;
 788
 789         if (!clk)
 790                 return;
 791
 792         rc = devres_release(dev, devm_clk_release, devm_clk_match, clk);
 793         WARN_ON(rc);
 794 }
 795
 796 int clk_uclass_post_probe(struct udevice *dev)
 797 {
 798         /*
 799          * when a clock provider is probed. Call clk_set_defaults()
 800          * also after the device is probed. This takes care of cases
 801          * where the DT is used to setup default parents and rates
 802          * using assigned-clocks
 803          */
 804         clk_set_defaults(dev, 1);
 805
 806         return 0;
 807 }
 808
 809 UCLASS_DRIVER(clk) = {
 810         .id             = UCLASS_CLK,
 811         .name           = "clk",
 812         .post_probe     = clk_uclass_post_probe,
 813 };