1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * This file is part of STM32 DAC driver 4 * 5 * Copyright (C) 2017, STMicroelectronics - All Rights Reserved 6 * Author: Fabrice Gasnier <fabrice.gasnier@st.com>. 7 * 8 */ 9 10 #include <linux/clk.h> 11 #include <linux/delay.h> 12 #include <linux/module.h> 13 #include <linux/of_platform.h> 14 #include <linux/pm_runtime.h> 15 #include <linux/regulator/consumer.h> 16 #include <linux/reset.h> 17 18 #include "stm32-dac-core.h" 19 20 /** 21 * struct stm32_dac_priv - stm32 DAC core private data 22 * @pclk: peripheral clock common for all DACs 23 * @rst: peripheral reset control 24 * @vref: regulator reference 25 * @common: Common data for all DAC instances 26 */ 27 struct stm32_dac_priv { 28 struct clk *pclk; 29 struct reset_control *rst; 30 struct regulator *vref; 31 struct stm32_dac_common common; 32 }; 33 34 /** 35 * struct stm32_dac_cfg - DAC configuration 36 * @has_hfsel: DAC has high frequency control 37 */ 38 struct stm32_dac_cfg { 39 bool has_hfsel; 40 }; 41 42 static struct stm32_dac_priv *to_stm32_dac_priv(struct stm32_dac_common *com) 43 { 44 return container_of(com, struct stm32_dac_priv, common); 45 } 46 47 static const struct regmap_config stm32_dac_regmap_cfg = { 48 .reg_bits = 32, 49 .val_bits = 32, 50 .reg_stride = sizeof(u32), 51 .max_register = 0x3fc, 52 }; 53 54 static int stm32_dac_core_hw_start(struct device *dev) 55 { 56 struct stm32_dac_common *common = dev_get_drvdata(dev); 57 struct stm32_dac_priv *priv = to_stm32_dac_priv(common); 58 int ret; 59 60 ret = regulator_enable(priv->vref); 61 if (ret < 0) { 62 dev_err(dev, "vref enable failed: %d\n", ret); 63 return ret; 64 } 65 66 ret = clk_prepare_enable(priv->pclk); 67 if (ret < 0) { 68 dev_err(dev, "pclk enable failed: %d\n", ret); 69 goto err_regulator_disable; 70 } 71 72 return 0; 73 74 err_regulator_disable: 75 regulator_disable(priv->vref); 76 77 return ret; 78 } 79 80 static void stm32_dac_core_hw_stop(struct device *dev) 81 { 82 struct stm32_dac_common *common = dev_get_drvdata(dev); 83 struct stm32_dac_priv *priv = to_stm32_dac_priv(common); 84 85 clk_disable_unprepare(priv->pclk); 86 regulator_disable(priv->vref); 87 } 88 89 static int stm32_dac_probe(struct platform_device *pdev) 90 { 91 struct device *dev = &pdev->dev; 92 const struct stm32_dac_cfg *cfg; 93 struct stm32_dac_priv *priv; 94 struct regmap *regmap; 95 struct resource *res; 96 void __iomem *mmio; 97 int ret; 98 99 if (!dev->of_node) 100 return -ENODEV; 101 102 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 103 if (!priv) 104 return -ENOMEM; 105 platform_set_drvdata(pdev, &priv->common); 106 107 cfg = (const struct stm32_dac_cfg *) 108 of_match_device(dev->driver->of_match_table, dev)->data; 109 110 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 111 mmio = devm_ioremap_resource(dev, res); 112 if (IS_ERR(mmio)) 113 return PTR_ERR(mmio); 114 115 regmap = devm_regmap_init_mmio_clk(dev, "pclk", mmio, 116 &stm32_dac_regmap_cfg); 117 if (IS_ERR(regmap)) 118 return PTR_ERR(regmap); 119 priv->common.regmap = regmap; 120 121 priv->pclk = devm_clk_get(dev, "pclk"); 122 if (IS_ERR(priv->pclk)) { 123 ret = PTR_ERR(priv->pclk); 124 dev_err(dev, "pclk get failed\n"); 125 return ret; 126 } 127 128 priv->vref = devm_regulator_get(dev, "vref"); 129 if (IS_ERR(priv->vref)) { 130 ret = PTR_ERR(priv->vref); 131 dev_err(dev, "vref get failed, %d\n", ret); 132 return ret; 133 } 134 135 pm_runtime_get_noresume(dev); 136 pm_runtime_set_active(dev); 137 pm_runtime_enable(dev); 138 139 ret = stm32_dac_core_hw_start(dev); 140 if (ret) 141 goto err_pm_stop; 142 143 ret = regulator_get_voltage(priv->vref); 144 if (ret < 0) { 145 dev_err(dev, "vref get voltage failed, %d\n", ret); 146 goto err_hw_stop; 147 } 148 priv->common.vref_mv = ret / 1000; 149 dev_dbg(dev, "vref+=%dmV\n", priv->common.vref_mv); 150 151 priv->rst = devm_reset_control_get_exclusive(dev, NULL); 152 if (!IS_ERR(priv->rst)) { 153 reset_control_assert(priv->rst); 154 udelay(2); 155 reset_control_deassert(priv->rst); 156 } 157 158 if (cfg && cfg->has_hfsel) { 159 /* When clock speed is higher than 80MHz, set HFSEL */ 160 priv->common.hfsel = (clk_get_rate(priv->pclk) > 80000000UL); 161 ret = regmap_update_bits(regmap, STM32_DAC_CR, 162 STM32H7_DAC_CR_HFSEL, 163 priv->common.hfsel ? 164 STM32H7_DAC_CR_HFSEL : 0); 165 if (ret) 166 goto err_hw_stop; 167 } 168 169 170 ret = of_platform_populate(pdev->dev.of_node, NULL, NULL, dev); 171 if (ret < 0) { 172 dev_err(dev, "failed to populate DT children\n"); 173 goto err_hw_stop; 174 } 175 176 pm_runtime_put(dev); 177 178 return 0; 179 180 err_hw_stop: 181 stm32_dac_core_hw_stop(dev); 182 err_pm_stop: 183 pm_runtime_disable(dev); 184 pm_runtime_set_suspended(dev); 185 pm_runtime_put_noidle(dev); 186 187 return ret; 188 } 189 190 static int stm32_dac_remove(struct platform_device *pdev) 191 { 192 pm_runtime_get_sync(&pdev->dev); 193 of_platform_depopulate(&pdev->dev); 194 stm32_dac_core_hw_stop(&pdev->dev); 195 pm_runtime_disable(&pdev->dev); 196 pm_runtime_set_suspended(&pdev->dev); 197 pm_runtime_put_noidle(&pdev->dev); 198 199 return 0; 200 } 201 202 static int __maybe_unused stm32_dac_core_resume(struct device *dev) 203 { 204 struct stm32_dac_common *common = dev_get_drvdata(dev); 205 struct stm32_dac_priv *priv = to_stm32_dac_priv(common); 206 int ret; 207 208 if (priv->common.hfsel) { 209 /* restore hfsel (maybe lost under low power state) */ 210 ret = regmap_update_bits(priv->common.regmap, STM32_DAC_CR, 211 STM32H7_DAC_CR_HFSEL, 212 STM32H7_DAC_CR_HFSEL); 213 if (ret) 214 return ret; 215 } 216 217 return pm_runtime_force_resume(dev); 218 } 219 220 static int __maybe_unused stm32_dac_core_runtime_suspend(struct device *dev) 221 { 222 stm32_dac_core_hw_stop(dev); 223 224 return 0; 225 } 226 227 static int __maybe_unused stm32_dac_core_runtime_resume(struct device *dev) 228 { 229 return stm32_dac_core_hw_start(dev); 230 } 231 232 static const struct dev_pm_ops stm32_dac_core_pm_ops = { 233 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, stm32_dac_core_resume) 234 SET_RUNTIME_PM_OPS(stm32_dac_core_runtime_suspend, 235 stm32_dac_core_runtime_resume, 236 NULL) 237 }; 238 239 static const struct stm32_dac_cfg stm32h7_dac_cfg = { 240 .has_hfsel = true, 241 }; 242 243 static const struct of_device_id stm32_dac_of_match[] = { 244 { 245 .compatible = "st,stm32f4-dac-core", 246 }, { 247 .compatible = "st,stm32h7-dac-core", 248 .data = (void *)&stm32h7_dac_cfg, 249 }, 250 {}, 251 }; 252 MODULE_DEVICE_TABLE(of, stm32_dac_of_match); 253 254 static struct platform_driver stm32_dac_driver = { 255 .probe = stm32_dac_probe, 256 .remove = stm32_dac_remove, 257 .driver = { 258 .name = "stm32-dac-core", 259 .of_match_table = stm32_dac_of_match, 260 .pm = &stm32_dac_core_pm_ops, 261 }, 262 }; 263 module_platform_driver(stm32_dac_driver); 264 265 MODULE_AUTHOR("Fabrice Gasnier <fabrice.gasnier@st.com>"); 266 MODULE_DESCRIPTION("STMicroelectronics STM32 DAC core driver"); 267 MODULE_LICENSE("GPL v2"); 268 MODULE_ALIAS("platform:stm32-dac-core"); 269