drivers/clk/clk_sandbox.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * (C) Copyright 2015 Google, Inc
   4  */
   5
   6 #include <common.h>
   7 #include <clk-uclass.h>
   8 #include <dm.h>
   9 #include <errno.h>
  10 #include <malloc.h>
  11 #include <asm/clk.h>
  12
  13 struct sandbox_clk_priv {
  14         bool probed;
  15         ulong rate[SANDBOX_CLK_ID_COUNT];
  16         bool enabled[SANDBOX_CLK_ID_COUNT];
  17         bool requested[SANDBOX_CLK_ID_COUNT];
  18 };
  19
  20 static ulong sandbox_clk_get_rate(struct clk *clk)
  21 {
  22         struct sandbox_clk_priv *priv = dev_get_priv(clk->dev);
  23
  24         if (!priv->probed)
  25                 return -ENODEV;
  26
  27         if (clk->id >= SANDBOX_CLK_ID_COUNT)
  28                 return -EINVAL;
  29
  30         return priv->rate[clk->id];
  31 }
  32
  33 static ulong sandbox_clk_set_rate(struct clk *clk, ulong rate)
  34 {
  35         struct sandbox_clk_priv *priv = dev_get_priv(clk->dev);
  36         ulong old_rate;
  37
  38         if (!priv->probed)
  39                 return -ENODEV;
  40
  41         if (clk->id >= SANDBOX_CLK_ID_COUNT)
  42                 return -EINVAL;
  43
  44         if (!rate)
  45                 return -EINVAL;
  46
  47         old_rate = priv->rate[clk->id];
  48         priv->rate[clk->id] = rate;
  49
  50         return old_rate;
  51 }
  52
  53 static int sandbox_clk_enable(struct clk *clk)
  54 {
  55         struct sandbox_clk_priv *priv = dev_get_priv(clk->dev);
  56
  57         if (!priv->probed)
  58                 return -ENODEV;
  59
  60         if (clk->id >= SANDBOX_CLK_ID_COUNT)
  61                 return -EINVAL;
  62
  63         priv->enabled[clk->id] = true;
  64
  65         return 0;
  66 }
  67
  68 static int sandbox_clk_disable(struct clk *clk)
  69 {
  70         struct sandbox_clk_priv *priv = dev_get_priv(clk->dev);
  71
  72         if (!priv->probed)
  73                 return -ENODEV;
  74
  75         if (clk->id >= SANDBOX_CLK_ID_COUNT)
  76                 return -EINVAL;
  77
  78         priv->enabled[clk->id] = false;
  79
  80         return 0;
  81 }
  82
  83 static int sandbox_clk_request(struct clk *clk)
  84 {
  85         struct sandbox_clk_priv *priv = dev_get_priv(clk->dev);
  86
  87         if (clk->id >= SANDBOX_CLK_ID_COUNT)
  88                 return -EINVAL;
  89
  90         priv->requested[clk->id] = true;
  91         return 0;
  92 }
  93
  94 static int sandbox_clk_free(struct clk *clk)
  95 {
  96         struct sandbox_clk_priv *priv = dev_get_priv(clk->dev);
  97
  98         if (clk->id >= SANDBOX_CLK_ID_COUNT)
  99                 return -EINVAL;
 100
 101         priv->requested[clk->id] = false;
 102         return 0;
 103 }
 104
 105 static struct clk_ops sandbox_clk_ops = {
 106         .get_rate       = sandbox_clk_get_rate,
 107         .set_rate       = sandbox_clk_set_rate,
 108         .enable         = sandbox_clk_enable,
 109         .disable        = sandbox_clk_disable,
 110         .request        = sandbox_clk_request,
 111         .rfree          = sandbox_clk_free,
 112 };
 113
 114 static int sandbox_clk_probe(struct udevice *dev)
 115 {
 116         struct sandbox_clk_priv *priv = dev_get_priv(dev);
 117
 118         priv->probed = true;
 119         return 0;
 120 }
 121
 122 static const struct udevice_id sandbox_clk_ids[] = {
 123         { .compatible = "sandbox,clk" },
 124         { }
 125 };
 126
 127 U_BOOT_DRIVER(clk_sandbox) = {
 128         .name           = "clk_sandbox",
 129         .id             = UCLASS_CLK,
 130         .of_match       = sandbox_clk_ids,
 131         .ops            = &sandbox_clk_ops,
 132         .probe          = sandbox_clk_probe,
 133         .priv_auto_alloc_size = sizeof(struct sandbox_clk_priv),
 134 };
 135
 136 ulong sandbox_clk_query_rate(struct udevice *dev, int id)
 137 {
 138         struct sandbox_clk_priv *priv = dev_get_priv(dev);
 139
 140         if (id < 0 || id >= SANDBOX_CLK_ID_COUNT)
 141                 return -EINVAL;
 142
 143         return priv->rate[id];
 144 }
 145
 146 int sandbox_clk_query_enable(struct udevice *dev, int id)
 147 {
 148         struct sandbox_clk_priv *priv = dev_get_priv(dev);
 149
 150         if (id < 0 || id >= SANDBOX_CLK_ID_COUNT)
 151                 return -EINVAL;
 152
 153         return priv->enabled[id];
 154 }
 155
 156 int sandbox_clk_query_requested(struct udevice *dev, int id)
 157 {
 158         struct sandbox_clk_priv *priv = dev_get_priv(dev);
 159
 160         if (id < 0 || id >= SANDBOX_CLK_ID_COUNT)
 161                 return -EINVAL;
 162         return priv->requested[id];
 163 }