1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * This file is part the core part STM32 DFSDM driver 4 * 5 * Copyright (C) 2017, STMicroelectronics - All Rights Reserved 6 * Author(s): Arnaud Pouliquen <arnaud.pouliquen@st.com> for STMicroelectronics. 7 */ 8 9 #include <linux/clk.h> 10 #include <linux/iio/iio.h> 11 #include <linux/iio/sysfs.h> 12 #include <linux/interrupt.h> 13 #include <linux/module.h> 14 #include <linux/of_device.h> 15 #include <linux/pinctrl/consumer.h> 16 #include <linux/pm_runtime.h> 17 #include <linux/regmap.h> 18 #include <linux/slab.h> 19 20 #include "stm32-dfsdm.h" 21 22 struct stm32_dfsdm_dev_data { 23 unsigned int num_filters; 24 unsigned int num_channels; 25 const struct regmap_config *regmap_cfg; 26 }; 27 28 #define STM32H7_DFSDM_NUM_FILTERS 4 29 #define STM32H7_DFSDM_NUM_CHANNELS 8 30 #define STM32MP1_DFSDM_NUM_FILTERS 6 31 #define STM32MP1_DFSDM_NUM_CHANNELS 8 32 33 static bool stm32_dfsdm_volatile_reg(struct device *dev, unsigned int reg) 34 { 35 if (reg < DFSDM_FILTER_BASE_ADR) 36 return false; 37 38 /* 39 * Mask is done on register to avoid to list registers of all 40 * filter instances. 41 */ 42 switch (reg & DFSDM_FILTER_REG_MASK) { 43 case DFSDM_CR1(0) & DFSDM_FILTER_REG_MASK: 44 case DFSDM_ISR(0) & DFSDM_FILTER_REG_MASK: 45 case DFSDM_JDATAR(0) & DFSDM_FILTER_REG_MASK: 46 case DFSDM_RDATAR(0) & DFSDM_FILTER_REG_MASK: 47 return true; 48 } 49 50 return false; 51 } 52 53 static const struct regmap_config stm32h7_dfsdm_regmap_cfg = { 54 .reg_bits = 32, 55 .val_bits = 32, 56 .reg_stride = sizeof(u32), 57 .max_register = 0x2B8, 58 .volatile_reg = stm32_dfsdm_volatile_reg, 59 .fast_io = true, 60 }; 61 62 static const struct stm32_dfsdm_dev_data stm32h7_dfsdm_data = { 63 .num_filters = STM32H7_DFSDM_NUM_FILTERS, 64 .num_channels = STM32H7_DFSDM_NUM_CHANNELS, 65 .regmap_cfg = &stm32h7_dfsdm_regmap_cfg, 66 }; 67 68 static const struct regmap_config stm32mp1_dfsdm_regmap_cfg = { 69 .reg_bits = 32, 70 .val_bits = 32, 71 .reg_stride = sizeof(u32), 72 .max_register = 0x7fc, 73 .volatile_reg = stm32_dfsdm_volatile_reg, 74 .fast_io = true, 75 }; 76 77 static const struct stm32_dfsdm_dev_data stm32mp1_dfsdm_data = { 78 .num_filters = STM32MP1_DFSDM_NUM_FILTERS, 79 .num_channels = STM32MP1_DFSDM_NUM_CHANNELS, 80 .regmap_cfg = &stm32mp1_dfsdm_regmap_cfg, 81 }; 82 83 struct dfsdm_priv { 84 struct platform_device *pdev; /* platform device */ 85 86 struct stm32_dfsdm dfsdm; /* common data exported for all instances */ 87 88 unsigned int spi_clk_out_div; /* SPI clkout divider value */ 89 atomic_t n_active_ch; /* number of current active channels */ 90 91 struct clk *clk; /* DFSDM clock */ 92 struct clk *aclk; /* audio clock */ 93 }; 94 95 static inline struct dfsdm_priv *to_stm32_dfsdm_priv(struct stm32_dfsdm *dfsdm) 96 { 97 return container_of(dfsdm, struct dfsdm_priv, dfsdm); 98 } 99 100 static int stm32_dfsdm_clk_prepare_enable(struct stm32_dfsdm *dfsdm) 101 { 102 struct dfsdm_priv *priv = to_stm32_dfsdm_priv(dfsdm); 103 int ret; 104 105 ret = clk_prepare_enable(priv->clk); 106 if (ret || !priv->aclk) 107 return ret; 108 109 ret = clk_prepare_enable(priv->aclk); 110 if (ret) 111 clk_disable_unprepare(priv->clk); 112 113 return ret; 114 } 115 116 static void stm32_dfsdm_clk_disable_unprepare(struct stm32_dfsdm *dfsdm) 117 { 118 struct dfsdm_priv *priv = to_stm32_dfsdm_priv(dfsdm); 119 120 if (priv->aclk) 121 clk_disable_unprepare(priv->aclk); 122 clk_disable_unprepare(priv->clk); 123 } 124 125 /** 126 * stm32_dfsdm_start_dfsdm - start global dfsdm interface. 127 * 128 * Enable interface if n_active_ch is not null. 129 * @dfsdm: Handle used to retrieve dfsdm context. 130 */ 131 int stm32_dfsdm_start_dfsdm(struct stm32_dfsdm *dfsdm) 132 { 133 struct dfsdm_priv *priv = to_stm32_dfsdm_priv(dfsdm); 134 struct device *dev = &priv->pdev->dev; 135 unsigned int clk_div = priv->spi_clk_out_div, clk_src; 136 int ret; 137 138 if (atomic_inc_return(&priv->n_active_ch) == 1) { 139 ret = pm_runtime_get_sync(dev); 140 if (ret < 0) { 141 pm_runtime_put_noidle(dev); 142 goto error_ret; 143 } 144 145 /* select clock source, e.g. 0 for "dfsdm" or 1 for "audio" */ 146 clk_src = priv->aclk ? 1 : 0; 147 ret = regmap_update_bits(dfsdm->regmap, DFSDM_CHCFGR1(0), 148 DFSDM_CHCFGR1_CKOUTSRC_MASK, 149 DFSDM_CHCFGR1_CKOUTSRC(clk_src)); 150 if (ret < 0) 151 goto pm_put; 152 153 /* Output the SPI CLKOUT (if clk_div == 0 clock if OFF) */ 154 ret = regmap_update_bits(dfsdm->regmap, DFSDM_CHCFGR1(0), 155 DFSDM_CHCFGR1_CKOUTDIV_MASK, 156 DFSDM_CHCFGR1_CKOUTDIV(clk_div)); 157 if (ret < 0) 158 goto pm_put; 159 160 /* Global enable of DFSDM interface */ 161 ret = regmap_update_bits(dfsdm->regmap, DFSDM_CHCFGR1(0), 162 DFSDM_CHCFGR1_DFSDMEN_MASK, 163 DFSDM_CHCFGR1_DFSDMEN(1)); 164 if (ret < 0) 165 goto pm_put; 166 } 167 168 dev_dbg(dev, "%s: n_active_ch %d\n", __func__, 169 atomic_read(&priv->n_active_ch)); 170 171 return 0; 172 173 pm_put: 174 pm_runtime_put_sync(dev); 175 error_ret: 176 atomic_dec(&priv->n_active_ch); 177 178 return ret; 179 } 180 EXPORT_SYMBOL_GPL(stm32_dfsdm_start_dfsdm); 181 182 /** 183 * stm32_dfsdm_stop_dfsdm - stop global DFSDM interface. 184 * 185 * Disable interface if n_active_ch is null 186 * @dfsdm: Handle used to retrieve dfsdm context. 187 */ 188 int stm32_dfsdm_stop_dfsdm(struct stm32_dfsdm *dfsdm) 189 { 190 struct dfsdm_priv *priv = to_stm32_dfsdm_priv(dfsdm); 191 int ret; 192 193 if (atomic_dec_and_test(&priv->n_active_ch)) { 194 /* Global disable of DFSDM interface */ 195 ret = regmap_update_bits(dfsdm->regmap, DFSDM_CHCFGR1(0), 196 DFSDM_CHCFGR1_DFSDMEN_MASK, 197 DFSDM_CHCFGR1_DFSDMEN(0)); 198 if (ret < 0) 199 return ret; 200 201 /* Stop SPI CLKOUT */ 202 ret = regmap_update_bits(dfsdm->regmap, DFSDM_CHCFGR1(0), 203 DFSDM_CHCFGR1_CKOUTDIV_MASK, 204 DFSDM_CHCFGR1_CKOUTDIV(0)); 205 if (ret < 0) 206 return ret; 207 208 pm_runtime_put_sync(&priv->pdev->dev); 209 } 210 dev_dbg(&priv->pdev->dev, "%s: n_active_ch %d\n", __func__, 211 atomic_read(&priv->n_active_ch)); 212 213 return 0; 214 } 215 EXPORT_SYMBOL_GPL(stm32_dfsdm_stop_dfsdm); 216 217 static int stm32_dfsdm_parse_of(struct platform_device *pdev, 218 struct dfsdm_priv *priv) 219 { 220 struct device_node *node = pdev->dev.of_node; 221 struct resource *res; 222 unsigned long clk_freq, divider; 223 unsigned int spi_freq, rem; 224 int ret; 225 226 if (!node) 227 return -EINVAL; 228 229 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 230 if (!res) { 231 dev_err(&pdev->dev, "Failed to get memory resource\n"); 232 return -ENODEV; 233 } 234 priv->dfsdm.phys_base = res->start; 235 priv->dfsdm.base = devm_ioremap_resource(&pdev->dev, res); 236 237 /* 238 * "dfsdm" clock is mandatory for DFSDM peripheral clocking. 239 * "dfsdm" or "audio" clocks can be used as source clock for 240 * the SPI clock out signal and internal processing, depending 241 * on use case. 242 */ 243 priv->clk = devm_clk_get(&pdev->dev, "dfsdm"); 244 if (IS_ERR(priv->clk)) { 245 dev_err(&pdev->dev, "No stm32_dfsdm_clk clock found\n"); 246 return -EINVAL; 247 } 248 249 priv->aclk = devm_clk_get(&pdev->dev, "audio"); 250 if (IS_ERR(priv->aclk)) 251 priv->aclk = NULL; 252 253 if (priv->aclk) 254 clk_freq = clk_get_rate(priv->aclk); 255 else 256 clk_freq = clk_get_rate(priv->clk); 257 258 /* SPI clock out frequency */ 259 ret = of_property_read_u32(pdev->dev.of_node, "spi-max-frequency", 260 &spi_freq); 261 if (ret < 0) { 262 /* No SPI master mode */ 263 return 0; 264 } 265 266 divider = div_u64_rem(clk_freq, spi_freq, &rem); 267 /* Round up divider when ckout isn't precise, not to exceed spi_freq */ 268 if (rem) 269 divider++; 270 271 /* programmable divider is in range of [2:256] */ 272 if (divider < 2 || divider > 256) { 273 dev_err(&pdev->dev, "spi-max-frequency not achievable\n"); 274 return -EINVAL; 275 } 276 277 /* SPI clock output divider is: divider = CKOUTDIV + 1 */ 278 priv->spi_clk_out_div = divider - 1; 279 priv->dfsdm.spi_master_freq = clk_freq / (priv->spi_clk_out_div + 1); 280 281 if (rem) { 282 dev_warn(&pdev->dev, "SPI clock not accurate\n"); 283 dev_warn(&pdev->dev, "%ld = %d * %d + %d\n", 284 clk_freq, spi_freq, priv->spi_clk_out_div + 1, rem); 285 } 286 287 return 0; 288 }; 289 290 static const struct of_device_id stm32_dfsdm_of_match[] = { 291 { 292 .compatible = "st,stm32h7-dfsdm", 293 .data = &stm32h7_dfsdm_data, 294 }, 295 { 296 .compatible = "st,stm32mp1-dfsdm", 297 .data = &stm32mp1_dfsdm_data, 298 }, 299 {} 300 }; 301 MODULE_DEVICE_TABLE(of, stm32_dfsdm_of_match); 302 303 static int stm32_dfsdm_probe(struct platform_device *pdev) 304 { 305 struct dfsdm_priv *priv; 306 const struct stm32_dfsdm_dev_data *dev_data; 307 struct stm32_dfsdm *dfsdm; 308 int ret; 309 310 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); 311 if (!priv) 312 return -ENOMEM; 313 314 priv->pdev = pdev; 315 316 dev_data = of_device_get_match_data(&pdev->dev); 317 318 dfsdm = &priv->dfsdm; 319 dfsdm->fl_list = devm_kcalloc(&pdev->dev, dev_data->num_filters, 320 sizeof(*dfsdm->fl_list), GFP_KERNEL); 321 if (!dfsdm->fl_list) 322 return -ENOMEM; 323 324 dfsdm->num_fls = dev_data->num_filters; 325 dfsdm->ch_list = devm_kcalloc(&pdev->dev, dev_data->num_channels, 326 sizeof(*dfsdm->ch_list), 327 GFP_KERNEL); 328 if (!dfsdm->ch_list) 329 return -ENOMEM; 330 dfsdm->num_chs = dev_data->num_channels; 331 332 ret = stm32_dfsdm_parse_of(pdev, priv); 333 if (ret < 0) 334 return ret; 335 336 dfsdm->regmap = devm_regmap_init_mmio_clk(&pdev->dev, "dfsdm", 337 dfsdm->base, 338 dev_data->regmap_cfg); 339 if (IS_ERR(dfsdm->regmap)) { 340 ret = PTR_ERR(dfsdm->regmap); 341 dev_err(&pdev->dev, "%s: Failed to allocate regmap: %d\n", 342 __func__, ret); 343 return ret; 344 } 345 346 platform_set_drvdata(pdev, dfsdm); 347 348 ret = stm32_dfsdm_clk_prepare_enable(dfsdm); 349 if (ret) { 350 dev_err(&pdev->dev, "Failed to start clock\n"); 351 return ret; 352 } 353 354 pm_runtime_get_noresume(&pdev->dev); 355 pm_runtime_set_active(&pdev->dev); 356 pm_runtime_enable(&pdev->dev); 357 358 ret = of_platform_populate(pdev->dev.of_node, NULL, NULL, &pdev->dev); 359 if (ret) 360 goto pm_put; 361 362 pm_runtime_put(&pdev->dev); 363 364 return 0; 365 366 pm_put: 367 pm_runtime_disable(&pdev->dev); 368 pm_runtime_set_suspended(&pdev->dev); 369 pm_runtime_put_noidle(&pdev->dev); 370 stm32_dfsdm_clk_disable_unprepare(dfsdm); 371 372 return ret; 373 } 374 375 static int stm32_dfsdm_core_remove(struct platform_device *pdev) 376 { 377 struct stm32_dfsdm *dfsdm = platform_get_drvdata(pdev); 378 379 pm_runtime_get_sync(&pdev->dev); 380 of_platform_depopulate(&pdev->dev); 381 pm_runtime_disable(&pdev->dev); 382 pm_runtime_set_suspended(&pdev->dev); 383 pm_runtime_put_noidle(&pdev->dev); 384 stm32_dfsdm_clk_disable_unprepare(dfsdm); 385 386 return 0; 387 } 388 389 static int __maybe_unused stm32_dfsdm_core_suspend(struct device *dev) 390 { 391 struct stm32_dfsdm *dfsdm = dev_get_drvdata(dev); 392 struct dfsdm_priv *priv = to_stm32_dfsdm_priv(dfsdm); 393 int ret; 394 395 ret = pm_runtime_force_suspend(dev); 396 if (ret) 397 return ret; 398 399 /* Balance devm_regmap_init_mmio_clk() clk_prepare() */ 400 clk_unprepare(priv->clk); 401 402 return pinctrl_pm_select_sleep_state(dev); 403 } 404 405 static int __maybe_unused stm32_dfsdm_core_resume(struct device *dev) 406 { 407 struct stm32_dfsdm *dfsdm = dev_get_drvdata(dev); 408 struct dfsdm_priv *priv = to_stm32_dfsdm_priv(dfsdm); 409 int ret; 410 411 ret = pinctrl_pm_select_default_state(dev); 412 if (ret) 413 return ret; 414 415 ret = clk_prepare(priv->clk); 416 if (ret) 417 return ret; 418 419 return pm_runtime_force_resume(dev); 420 } 421 422 static int __maybe_unused stm32_dfsdm_core_runtime_suspend(struct device *dev) 423 { 424 struct stm32_dfsdm *dfsdm = dev_get_drvdata(dev); 425 426 stm32_dfsdm_clk_disable_unprepare(dfsdm); 427 428 return 0; 429 } 430 431 static int __maybe_unused stm32_dfsdm_core_runtime_resume(struct device *dev) 432 { 433 struct stm32_dfsdm *dfsdm = dev_get_drvdata(dev); 434 435 return stm32_dfsdm_clk_prepare_enable(dfsdm); 436 } 437 438 static const struct dev_pm_ops stm32_dfsdm_core_pm_ops = { 439 SET_SYSTEM_SLEEP_PM_OPS(stm32_dfsdm_core_suspend, 440 stm32_dfsdm_core_resume) 441 SET_RUNTIME_PM_OPS(stm32_dfsdm_core_runtime_suspend, 442 stm32_dfsdm_core_runtime_resume, 443 NULL) 444 }; 445 446 static struct platform_driver stm32_dfsdm_driver = { 447 .probe = stm32_dfsdm_probe, 448 .remove = stm32_dfsdm_core_remove, 449 .driver = { 450 .name = "stm32-dfsdm", 451 .of_match_table = stm32_dfsdm_of_match, 452 .pm = &stm32_dfsdm_core_pm_ops, 453 }, 454 }; 455 456 module_platform_driver(stm32_dfsdm_driver); 457 458 MODULE_AUTHOR("Arnaud Pouliquen <arnaud.pouliquen@st.com>"); 459 MODULE_DESCRIPTION("STMicroelectronics STM32 dfsdm driver"); 460 MODULE_LICENSE("GPL v2"); 461