drivers/iio/dac/stm32-dac-core.c

   1 /*
   2  * This file is part of STM32 DAC driver
   3  *
   4  * Copyright (C) 2017, STMicroelectronics - All Rights Reserved
   5  * Author: Fabrice Gasnier <fabrice.gasnier@st.com>.
   6  *
   7  * License type: GPLv2
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License version 2 as published by
  11  * the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  15  * or FITNESS FOR A PARTICULAR PURPOSE.
  16  * See the GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along with
  19  * this program. If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <linux/clk.h>
  23 #include <linux/delay.h>
  24 #include <linux/module.h>
  25 #include <linux/of_platform.h>
  26 #include <linux/regulator/consumer.h>
  27 #include <linux/reset.h>
  28
  29 #include "stm32-dac-core.h"
  30
  31 /**
  32  * struct stm32_dac_priv - stm32 DAC core private data
  33  * @pclk:               peripheral clock common for all DACs
  34  * @rst:                peripheral reset control
  35  * @vref:               regulator reference
  36  * @common:             Common data for all DAC instances
  37  */
  38 struct stm32_dac_priv {
  39         struct clk *pclk;
  40         struct reset_control *rst;
  41         struct regulator *vref;
  42         struct stm32_dac_common common;
  43 };
  44
  45 /**
  46  * struct stm32_dac_cfg - DAC configuration
  47  * @has_hfsel: DAC has high frequency control
  48  */
  49 struct stm32_dac_cfg {
  50         bool has_hfsel;
  51 };
  52
  53 static struct stm32_dac_priv *to_stm32_dac_priv(struct stm32_dac_common *com)
  54 {
  55         return container_of(com, struct stm32_dac_priv, common);
  56 }
  57
  58 static const struct regmap_config stm32_dac_regmap_cfg = {
  59         .reg_bits = 32,
  60         .val_bits = 32,
  61         .reg_stride = sizeof(u32),
  62         .max_register = 0x3fc,
  63 };
  64
  65 static int stm32_dac_probe(struct platform_device *pdev)
  66 {
  67         struct device *dev = &pdev->dev;
  68         const struct stm32_dac_cfg *cfg;
  69         struct stm32_dac_priv *priv;
  70         struct regmap *regmap;
  71         struct resource *res;
  72         void __iomem *mmio;
  73         int ret;
  74
  75         if (!dev->of_node)
  76                 return -ENODEV;
  77
  78         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
  79         if (!priv)
  80                 return -ENOMEM;
  81         cfg = (const struct stm32_dac_cfg *)
  82                 of_match_device(dev->driver->of_match_table, dev)->data;
  83
  84         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  85         mmio = devm_ioremap_resource(dev, res);
  86         if (IS_ERR(mmio))
  87                 return PTR_ERR(mmio);
  88
  89         regmap = devm_regmap_init_mmio(dev, mmio, &stm32_dac_regmap_cfg);
  90         if (IS_ERR(regmap))
  91                 return PTR_ERR(regmap);
  92         priv->common.regmap = regmap;
  93
  94         priv->vref = devm_regulator_get(dev, "vref");
  95         if (IS_ERR(priv->vref)) {
  96                 ret = PTR_ERR(priv->vref);
  97                 dev_err(dev, "vref get failed, %d\n", ret);
  98                 return ret;
  99         }
 100
 101         ret = regulator_enable(priv->vref);
 102         if (ret < 0) {
 103                 dev_err(dev, "vref enable failed\n");
 104                 return ret;
 105         }
 106
 107         ret = regulator_get_voltage(priv->vref);
 108         if (ret < 0) {
 109                 dev_err(dev, "vref get voltage failed, %d\n", ret);
 110                 goto err_vref;
 111         }
 112         priv->common.vref_mv = ret / 1000;
 113         dev_dbg(dev, "vref+=%dmV\n", priv->common.vref_mv);
 114
 115         priv->pclk = devm_clk_get(dev, "pclk");
 116         if (IS_ERR(priv->pclk)) {
 117                 ret = PTR_ERR(priv->pclk);
 118                 dev_err(dev, "pclk get failed\n");
 119                 goto err_vref;
 120         }
 121
 122         ret = clk_prepare_enable(priv->pclk);
 123         if (ret < 0) {
 124                 dev_err(dev, "pclk enable failed\n");
 125                 goto err_vref;
 126         }
 127
 128         priv->rst = devm_reset_control_get_exclusive(dev, NULL);
 129         if (!IS_ERR(priv->rst)) {
 130                 reset_control_assert(priv->rst);
 131                 udelay(2);
 132                 reset_control_deassert(priv->rst);
 133         }
 134
 135         if (cfg && cfg->has_hfsel) {
 136                 /* When clock speed is higher than 80MHz, set HFSEL */
 137                 priv->common.hfsel = (clk_get_rate(priv->pclk) > 80000000UL);
 138                 ret = regmap_update_bits(regmap, STM32_DAC_CR,
 139                                          STM32H7_DAC_CR_HFSEL,
 140                                          priv->common.hfsel ?
 141                                          STM32H7_DAC_CR_HFSEL : 0);
 142                 if (ret)
 143                         goto err_pclk;
 144         }
 145
 146         platform_set_drvdata(pdev, &priv->common);
 147
 148         ret = of_platform_populate(pdev->dev.of_node, NULL, NULL, dev);
 149         if (ret < 0) {
 150                 dev_err(dev, "failed to populate DT children\n");
 151                 goto err_pclk;
 152         }
 153
 154         return 0;
 155
 156 err_pclk:
 157         clk_disable_unprepare(priv->pclk);
 158 err_vref:
 159         regulator_disable(priv->vref);
 160
 161         return ret;
 162 }
 163
 164 static int stm32_dac_remove(struct platform_device *pdev)
 165 {
 166         struct stm32_dac_common *common = platform_get_drvdata(pdev);
 167         struct stm32_dac_priv *priv = to_stm32_dac_priv(common);
 168
 169         of_platform_depopulate(&pdev->dev);
 170         clk_disable_unprepare(priv->pclk);
 171         regulator_disable(priv->vref);
 172
 173         return 0;
 174 }
 175
 176 static const struct stm32_dac_cfg stm32h7_dac_cfg = {
 177         .has_hfsel = true,
 178 };
 179
 180 static const struct of_device_id stm32_dac_of_match[] = {
 181         {
 182                 .compatible = "st,stm32f4-dac-core",
 183         }, {
 184                 .compatible = "st,stm32h7-dac-core",
 185                 .data = (void *)&stm32h7_dac_cfg,
 186         },
 187         {},
 188 };
 189 MODULE_DEVICE_TABLE(of, stm32_dac_of_match);
 190
 191 static struct platform_driver stm32_dac_driver = {
 192         .probe = stm32_dac_probe,
 193         .remove = stm32_dac_remove,
 194         .driver = {
 195                 .name = "stm32-dac-core",
 196                 .of_match_table = stm32_dac_of_match,
 197         },
 198 };
 199 module_platform_driver(stm32_dac_driver);
 200
 201 MODULE_AUTHOR("Fabrice Gasnier <fabrice.gasnier@st.com>");
 202 MODULE_DESCRIPTION("STMicroelectronics STM32 DAC core driver");
 203 MODULE_LICENSE("GPL v2");
 204 MODULE_ALIAS("platform:stm32-dac-core");