drivers/regulator/stm32-vrefbuf.c

   1 /*
   2  * Copyright (C) STMicroelectronics 2017
   3  *
   4  * Author: Fabrice Gasnier <fabrice.gasnier@st.com>
   5  *
   6  * License terms:  GNU General Public License (GPL), version 2
   7  */
   8
   9 #include <linux/bitfield.h>
  10 #include <linux/clk.h>
  11 #include <linux/io.h>
  12 #include <linux/iopoll.h>
  13 #include <linux/module.h>
  14 #include <linux/of_device.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/regulator/driver.h>
  17 #include <linux/regulator/of_regulator.h>
  18
  19 /* STM32 VREFBUF registers */
  20 #define STM32_VREFBUF_CSR               0x00
  21
  22 /* STM32 VREFBUF CSR bitfields */
  23 #define STM32_VRS                       GENMASK(6, 4)
  24 #define STM32_VRR                       BIT(3)
  25 #define STM32_HIZ                       BIT(1)
  26 #define STM32_ENVR                      BIT(0)
  27
  28 struct stm32_vrefbuf {
  29         void __iomem *base;
  30         struct clk *clk;
  31 };
  32
  33 static const unsigned int stm32_vrefbuf_voltages[] = {
  34         /* Matches resp. VRS = 000b, 001b, 010b, 011b */
  35         2500000, 2048000, 1800000, 1500000,
  36 };
  37
  38 static int stm32_vrefbuf_enable(struct regulator_dev *rdev)
  39 {
  40         struct stm32_vrefbuf *priv = rdev_get_drvdata(rdev);
  41         u32 val = readl_relaxed(priv->base + STM32_VREFBUF_CSR);
  42         int ret;
  43
  44         val = (val & ~STM32_HIZ) | STM32_ENVR;
  45         writel_relaxed(val, priv->base + STM32_VREFBUF_CSR);
  46
  47         /*
  48          * Vrefbuf startup time depends on external capacitor: wait here for
  49          * VRR to be set. That means output has reached expected value.
  50          * ~650us sleep should be enough for caps up to 1.5uF. Use 10ms as
  51          * arbitrary timeout.
  52          */
  53         ret = readl_poll_timeout(priv->base + STM32_VREFBUF_CSR, val,
  54                                  !(val & STM32_VRR), 650, 10000);
  55         if (ret) {
  56                 dev_err(&rdev->dev, "stm32 vrefbuf timed out!\n");
  57                 val = readl_relaxed(priv->base + STM32_VREFBUF_CSR);
  58                 val = (val & ~STM32_ENVR) | STM32_HIZ;
  59                 writel_relaxed(val, priv->base + STM32_VREFBUF_CSR);
  60         }
  61
  62         return ret;
  63 }
  64
  65 static int stm32_vrefbuf_disable(struct regulator_dev *rdev)
  66 {
  67         struct stm32_vrefbuf *priv = rdev_get_drvdata(rdev);
  68         u32 val = readl_relaxed(priv->base + STM32_VREFBUF_CSR);
  69
  70         val = (val & ~STM32_ENVR) | STM32_HIZ;
  71         writel_relaxed(val, priv->base + STM32_VREFBUF_CSR);
  72
  73         return 0;
  74 }
  75
  76 static int stm32_vrefbuf_is_enabled(struct regulator_dev *rdev)
  77 {
  78         struct stm32_vrefbuf *priv = rdev_get_drvdata(rdev);
  79
  80         return readl_relaxed(priv->base + STM32_VREFBUF_CSR) & STM32_ENVR;
  81 }
  82
  83 static int stm32_vrefbuf_set_voltage_sel(struct regulator_dev *rdev,
  84                                          unsigned sel)
  85 {
  86         struct stm32_vrefbuf *priv = rdev_get_drvdata(rdev);
  87         u32 val = readl_relaxed(priv->base + STM32_VREFBUF_CSR);
  88
  89         val = (val & ~STM32_VRS) | FIELD_PREP(STM32_VRS, sel);
  90         writel_relaxed(val, priv->base + STM32_VREFBUF_CSR);
  91
  92         return 0;
  93 }
  94
  95 static int stm32_vrefbuf_get_voltage_sel(struct regulator_dev *rdev)
  96 {
  97         struct stm32_vrefbuf *priv = rdev_get_drvdata(rdev);
  98         u32 val = readl_relaxed(priv->base + STM32_VREFBUF_CSR);
  99
 100         return FIELD_GET(STM32_VRS, val);
 101 }
 102
 103 static const struct regulator_ops stm32_vrefbuf_volt_ops = {
 104         .enable         = stm32_vrefbuf_enable,
 105         .disable        = stm32_vrefbuf_disable,
 106         .is_enabled     = stm32_vrefbuf_is_enabled,
 107         .get_voltage_sel = stm32_vrefbuf_get_voltage_sel,
 108         .set_voltage_sel = stm32_vrefbuf_set_voltage_sel,
 109         .list_voltage   = regulator_list_voltage_table,
 110 };
 111
 112 static const struct regulator_desc stm32_vrefbuf_regu = {
 113         .name = "vref",
 114         .supply_name = "vdda",
 115         .volt_table = stm32_vrefbuf_voltages,
 116         .n_voltages = ARRAY_SIZE(stm32_vrefbuf_voltages),
 117         .ops = &stm32_vrefbuf_volt_ops,
 118         .type = REGULATOR_VOLTAGE,
 119         .owner = THIS_MODULE,
 120 };
 121
 122 static int stm32_vrefbuf_probe(struct platform_device *pdev)
 123 {
 124         struct resource *res;
 125         struct stm32_vrefbuf *priv;
 126         struct regulator_config config = { };
 127         struct regulator_dev *rdev;
 128         int ret;
 129
 130         priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
 131         if (!priv)
 132                 return -ENOMEM;
 133
 134         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 135         priv->base = devm_ioremap_resource(&pdev->dev, res);
 136         if (IS_ERR(priv->base))
 137                 return PTR_ERR(priv->base);
 138
 139         priv->clk = devm_clk_get(&pdev->dev, NULL);
 140         if (IS_ERR(priv->clk))
 141                 return PTR_ERR(priv->clk);
 142
 143         ret = clk_prepare_enable(priv->clk);
 144         if (ret) {
 145                 dev_err(&pdev->dev, "clk prepare failed with error %d\n", ret);
 146                 return ret;
 147         }
 148
 149         config.dev = &pdev->dev;
 150         config.driver_data = priv;
 151         config.of_node = pdev->dev.of_node;
 152         config.init_data = of_get_regulator_init_data(&pdev->dev,
 153                                                       pdev->dev.of_node,
 154                                                       &stm32_vrefbuf_regu);
 155
 156         rdev = regulator_register(&stm32_vrefbuf_regu, &config);
 157         if (IS_ERR(rdev)) {
 158                 ret = PTR_ERR(rdev);
 159                 dev_err(&pdev->dev, "register failed with error %d\n", ret);
 160                 goto err_clk_dis;
 161         }
 162         platform_set_drvdata(pdev, rdev);
 163
 164         return 0;
 165
 166 err_clk_dis:
 167         clk_disable_unprepare(priv->clk);
 168
 169         return ret;
 170 }
 171
 172 static int stm32_vrefbuf_remove(struct platform_device *pdev)
 173 {
 174         struct regulator_dev *rdev = platform_get_drvdata(pdev);
 175         struct stm32_vrefbuf *priv = rdev_get_drvdata(rdev);
 176
 177         regulator_unregister(rdev);
 178         clk_disable_unprepare(priv->clk);
 179
 180         return 0;
 181 };
 182
 183 static const struct of_device_id stm32_vrefbuf_of_match[] = {
 184         { .compatible = "st,stm32-vrefbuf", },
 185         {},
 186 };
 187 MODULE_DEVICE_TABLE(of, stm32_vrefbuf_of_match);
 188
 189 static struct platform_driver stm32_vrefbuf_driver = {
 190         .probe = stm32_vrefbuf_probe,
 191         .remove = stm32_vrefbuf_remove,
 192         .driver = {
 193                 .name  = "stm32-vrefbuf",
 194                 .of_match_table = of_match_ptr(stm32_vrefbuf_of_match),
 195         },
 196 };
 197 module_platform_driver(stm32_vrefbuf_driver);
 198
 199 MODULE_LICENSE("GPL v2");
 200 MODULE_AUTHOR("Fabrice Gasnier <fabrice.gasnier@st.com>");
 201 MODULE_DESCRIPTION("STMicroelectronics STM32 VREFBUF driver");
 202 MODULE_ALIAS("platform:stm32-vrefbuf");