drivers/iio/dac/stm32-dac.c

   1 /*
   2  * This file is part of STM32 DAC driver
   3  *
   4  * Copyright (C) 2017, STMicroelectronics - All Rights Reserved
   5  * Authors: Amelie Delaunay <[email protected]>
   6  *          Fabrice Gasnier <[email protected]>
   7  *
   8  * License type: GPLv2
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License version 2 as published by
  12  * the Free Software Foundation.
  13  *
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16  * or FITNESS FOR A PARTICULAR PURPOSE.
  17  * See the GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License along with
  20  * this program. If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include <linux/bitfield.h>
  24 #include <linux/delay.h>
  25 #include <linux/iio/iio.h>
  26 #include <linux/kernel.h>
  27 #include <linux/module.h>
  28 #include <linux/platform_device.h>
  29
  30 #include "stm32-dac-core.h"
  31
  32 #define STM32_DAC_CHANNEL_1             1
  33 #define STM32_DAC_CHANNEL_2             2
  34 #define STM32_DAC_IS_CHAN_1(ch)         ((ch) & STM32_DAC_CHANNEL_1)
  35
  36 /**
  37  * struct stm32_dac - private data of DAC driver
  38  * @common:             reference to DAC common data
  39  */
  40 struct stm32_dac {
  41         struct stm32_dac_common *common;
  42 };
  43
  44 static int stm32_dac_is_enabled(struct iio_dev *indio_dev, int channel)
  45 {
  46         struct stm32_dac *dac = iio_priv(indio_dev);
  47         u32 en, val;
  48         int ret;
  49
  50         ret = regmap_read(dac->common->regmap, STM32_DAC_CR, &val);
  51         if (ret < 0)
  52                 return ret;
  53         if (STM32_DAC_IS_CHAN_1(channel))
  54                 en = FIELD_GET(STM32_DAC_CR_EN1, val);
  55         else
  56                 en = FIELD_GET(STM32_DAC_CR_EN2, val);
  57
  58         return !!en;
  59 }
  60
  61 static int stm32_dac_set_enable_state(struct iio_dev *indio_dev, int ch,
  62                                       bool enable)
  63 {
  64         struct stm32_dac *dac = iio_priv(indio_dev);
  65         u32 msk = STM32_DAC_IS_CHAN_1(ch) ? STM32_DAC_CR_EN1 : STM32_DAC_CR_EN2;
  66         u32 en = enable ? msk : 0;
  67         int ret;
  68
  69         ret = regmap_update_bits(dac->common->regmap, STM32_DAC_CR, msk, en);
  70         if (ret < 0) {
  71                 dev_err(&indio_dev->dev, "%s failed\n", en ?
  72                         "Enable" : "Disable");
  73                 return ret;
  74         }
  75
  76         /*
  77          * When HFSEL is set, it is not allowed to write the DHRx register
  78          * during 8 clock cycles after the ENx bit is set. It is not allowed
  79          * to make software/hardware trigger during this period either.
  80          */
  81         if (en && dac->common->hfsel)
  82                 udelay(1);
  83
  84         return 0;
  85 }
  86
  87 static int stm32_dac_get_value(struct stm32_dac *dac, int channel, int *val)
  88 {
  89         int ret;
  90
  91         if (STM32_DAC_IS_CHAN_1(channel))
  92                 ret = regmap_read(dac->common->regmap, STM32_DAC_DOR1, val);
  93         else
  94                 ret = regmap_read(dac->common->regmap, STM32_DAC_DOR2, val);
  95
  96         return ret ? ret : IIO_VAL_INT;
  97 }
  98
  99 static int stm32_dac_set_value(struct stm32_dac *dac, int channel, int val)
 100 {
 101         int ret;
 102
 103         if (STM32_DAC_IS_CHAN_1(channel))
 104                 ret = regmap_write(dac->common->regmap, STM32_DAC_DHR12R1, val);
 105         else
 106                 ret = regmap_write(dac->common->regmap, STM32_DAC_DHR12R2, val);
 107
 108         return ret;
 109 }
 110
 111 static int stm32_dac_read_raw(struct iio_dev *indio_dev,
 112                               struct iio_chan_spec const *chan,
 113                               int *val, int *val2, long mask)
 114 {
 115         struct stm32_dac *dac = iio_priv(indio_dev);
 116
 117         switch (mask) {
 118         case IIO_CHAN_INFO_RAW:
 119                 return stm32_dac_get_value(dac, chan->channel, val);
 120         case IIO_CHAN_INFO_SCALE:
 121                 *val = dac->common->vref_mv;
 122                 *val2 = chan->scan_type.realbits;
 123                 return IIO_VAL_FRACTIONAL_LOG2;
 124         default:
 125                 return -EINVAL;
 126         }
 127 }
 128
 129 static int stm32_dac_write_raw(struct iio_dev *indio_dev,
 130                                struct iio_chan_spec const *chan,
 131                                int val, int val2, long mask)
 132 {
 133         struct stm32_dac *dac = iio_priv(indio_dev);
 134
 135         switch (mask) {
 136         case IIO_CHAN_INFO_RAW:
 137                 return stm32_dac_set_value(dac, chan->channel, val);
 138         default:
 139                 return -EINVAL;
 140         }
 141 }
 142
 143 static int stm32_dac_debugfs_reg_access(struct iio_dev *indio_dev,
 144                                         unsigned reg, unsigned writeval,
 145                                         unsigned *readval)
 146 {
 147         struct stm32_dac *dac = iio_priv(indio_dev);
 148
 149         if (!readval)
 150                 return regmap_write(dac->common->regmap, reg, writeval);
 151         else
 152                 return regmap_read(dac->common->regmap, reg, readval);
 153 }
 154
 155 static const struct iio_info stm32_dac_iio_info = {
 156         .read_raw = stm32_dac_read_raw,
 157         .write_raw = stm32_dac_write_raw,
 158         .debugfs_reg_access = stm32_dac_debugfs_reg_access,
 159         .driver_module = THIS_MODULE,
 160 };
 161
 162 static const char * const stm32_dac_powerdown_modes[] = {
 163         "three_state",
 164 };
 165
 166 static int stm32_dac_get_powerdown_mode(struct iio_dev *indio_dev,
 167                                         const struct iio_chan_spec *chan)
 168 {
 169         return 0;
 170 }
 171
 172 static int stm32_dac_set_powerdown_mode(struct iio_dev *indio_dev,
 173                                         const struct iio_chan_spec *chan,
 174                                         unsigned int type)
 175 {
 176         return 0;
 177 }
 178
 179 static ssize_t stm32_dac_read_powerdown(struct iio_dev *indio_dev,
 180                                         uintptr_t private,
 181                                         const struct iio_chan_spec *chan,
 182                                         char *buf)
 183 {
 184         int ret = stm32_dac_is_enabled(indio_dev, chan->channel);
 185
 186         if (ret < 0)
 187                 return ret;
 188
 189         return sprintf(buf, "%d\n", ret ? 0 : 1);
 190 }
 191
 192 static ssize_t stm32_dac_write_powerdown(struct iio_dev *indio_dev,
 193                                          uintptr_t private,
 194                                          const struct iio_chan_spec *chan,
 195                                          const char *buf, size_t len)
 196 {
 197         bool powerdown;
 198         int ret;
 199
 200         ret = strtobool(buf, &powerdown);
 201         if (ret)
 202                 return ret;
 203
 204         ret = stm32_dac_set_enable_state(indio_dev, chan->channel, !powerdown);
 205         if (ret)
 206                 return ret;
 207
 208         return len;
 209 }
 210
 211 static const struct iio_enum stm32_dac_powerdown_mode_en = {
 212         .items = stm32_dac_powerdown_modes,
 213         .num_items = ARRAY_SIZE(stm32_dac_powerdown_modes),
 214         .get = stm32_dac_get_powerdown_mode,
 215         .set = stm32_dac_set_powerdown_mode,
 216 };
 217
 218 static const struct iio_chan_spec_ext_info stm32_dac_ext_info[] = {
 219         {
 220                 .name = "powerdown",
 221                 .read = stm32_dac_read_powerdown,
 222                 .write = stm32_dac_write_powerdown,
 223                 .shared = IIO_SEPARATE,
 224         },
 225         IIO_ENUM("powerdown_mode", IIO_SEPARATE, &stm32_dac_powerdown_mode_en),
 226         IIO_ENUM_AVAILABLE("powerdown_mode", &stm32_dac_powerdown_mode_en),
 227         {},
 228 };
 229
 230 #define STM32_DAC_CHANNEL(chan, name) {                 \
 231         .type = IIO_VOLTAGE,                            \
 232         .indexed = 1,                                   \
 233         .output = 1,                                    \
 234         .channel = chan,                                \
 235         .info_mask_separate =                           \
 236                 BIT(IIO_CHAN_INFO_RAW) |                \
 237                 BIT(IIO_CHAN_INFO_SCALE),               \
 238         /* scan_index is always 0 as num_channels is 1 */ \
 239         .scan_type = {                                  \
 240                 .sign = 'u',                            \
 241                 .realbits = 12,                         \
 242                 .storagebits = 16,                      \
 243         },                                              \
 244         .datasheet_name = name,                         \
 245         .ext_info = stm32_dac_ext_info                  \
 246 }
 247
 248 static const struct iio_chan_spec stm32_dac_channels[] = {
 249         STM32_DAC_CHANNEL(STM32_DAC_CHANNEL_1, "out1"),
 250         STM32_DAC_CHANNEL(STM32_DAC_CHANNEL_2, "out2"),
 251 };
 252
 253 static int stm32_dac_chan_of_init(struct iio_dev *indio_dev)
 254 {
 255         struct device_node *np = indio_dev->dev.of_node;
 256         unsigned int i;
 257         u32 channel;
 258         int ret;
 259
 260         ret = of_property_read_u32(np, "reg", &channel);
 261         if (ret) {
 262                 dev_err(&indio_dev->dev, "Failed to read reg property\n");
 263                 return ret;
 264         }
 265
 266         for (i = 0; i < ARRAY_SIZE(stm32_dac_channels); i++) {
 267                 if (stm32_dac_channels[i].channel == channel)
 268                         break;
 269         }
 270         if (i >= ARRAY_SIZE(stm32_dac_channels)) {
 271                 dev_err(&indio_dev->dev, "Invalid st,dac-channel\n");
 272                 return -EINVAL;
 273         }
 274
 275         indio_dev->channels = &stm32_dac_channels[i];
 276         /*
 277          * Expose only one channel here, as they can be used independently,
 278          * with separate trigger. Then separate IIO devices are instantiated
 279          * to manage this.
 280          */
 281         indio_dev->num_channels = 1;
 282
 283         return 0;
 284 };
 285
 286 static int stm32_dac_probe(struct platform_device *pdev)
 287 {
 288         struct device_node *np = pdev->dev.of_node;
 289         struct iio_dev *indio_dev;
 290         struct stm32_dac *dac;
 291         int ret;
 292
 293         if (!np)
 294                 return -ENODEV;
 295
 296         indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*dac));
 297         if (!indio_dev)
 298                 return -ENOMEM;
 299         platform_set_drvdata(pdev, indio_dev);
 300
 301         dac = iio_priv(indio_dev);
 302         dac->common = dev_get_drvdata(pdev->dev.parent);
 303         indio_dev->name = dev_name(&pdev->dev);
 304         indio_dev->dev.parent = &pdev->dev;
 305         indio_dev->dev.of_node = pdev->dev.of_node;
 306         indio_dev->info = &stm32_dac_iio_info;
 307         indio_dev->modes = INDIO_DIRECT_MODE;
 308
 309         ret = stm32_dac_chan_of_init(indio_dev);
 310         if (ret < 0)
 311                 return ret;
 312
 313         return devm_iio_device_register(&pdev->dev, indio_dev);
 314 }
 315
 316 static const struct of_device_id stm32_dac_of_match[] = {
 317         { .compatible = "st,stm32-dac", },
 318         {},
 319 };
 320 MODULE_DEVICE_TABLE(of, stm32_dac_of_match);
 321
 322 static struct platform_driver stm32_dac_driver = {
 323         .probe = stm32_dac_probe,
 324         .driver = {
 325                 .name = "stm32-dac",
 326                 .of_match_table = stm32_dac_of_match,
 327         },
 328 };
 329 module_platform_driver(stm32_dac_driver);
 330
 331 MODULE_ALIAS("platform:stm32-dac");
 332 MODULE_AUTHOR("Amelie Delaunay <[email protected]>");
 333 MODULE_DESCRIPTION("STMicroelectronics STM32 DAC driver");
 334 MODULE_LICENSE("GPL v2");