drivers/iio/dac/vf610_dac.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Freescale Vybrid vf610 DAC driver
   4  *
   5  * Copyright 2016 Toradex AG
   6  */
   7
   8 #include <linux/clk.h>
   9 #include <linux/err.h>
  10 #include <linux/interrupt.h>
  11 #include <linux/io.h>
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/regulator/consumer.h>
  16 #include <linux/slab.h>
  17
  18 #include <linux/iio/iio.h>
  19 #include <linux/iio/sysfs.h>
  20
  21 #define VF610_DACx_STATCTRL             0x20
  22
  23 #define VF610_DAC_DACEN                 BIT(15)
  24 #define VF610_DAC_DACRFS                BIT(14)
  25 #define VF610_DAC_LPEN                  BIT(11)
  26
  27 #define VF610_DAC_DAT0(x)               ((x) & 0xFFF)
  28
  29 enum vf610_conversion_mode_sel {
  30         VF610_DAC_CONV_HIGH_POWER,
  31         VF610_DAC_CONV_LOW_POWER,
  32 };
  33
  34 struct vf610_dac {
  35         struct clk *clk;
  36         struct device *dev;
  37         enum vf610_conversion_mode_sel conv_mode;
  38         void __iomem *regs;
  39 };
  40
  41 static void vf610_dac_init(struct vf610_dac *info)
  42 {
  43         int val;
  44
  45         info->conv_mode = VF610_DAC_CONV_LOW_POWER;
  46         val = VF610_DAC_DACEN | VF610_DAC_DACRFS |
  47                 VF610_DAC_LPEN;
  48         writel(val, info->regs + VF610_DACx_STATCTRL);
  49 }
  50
  51 static void vf610_dac_exit(struct vf610_dac *info)
  52 {
  53         int val;
  54
  55         val = readl(info->regs + VF610_DACx_STATCTRL);
  56         val &= ~VF610_DAC_DACEN;
  57         writel(val, info->regs + VF610_DACx_STATCTRL);
  58 }
  59
  60 static int vf610_set_conversion_mode(struct iio_dev *indio_dev,
  61                                 const struct iio_chan_spec *chan,
  62                                 unsigned int mode)
  63 {
  64         struct vf610_dac *info = iio_priv(indio_dev);
  65         int val;
  66
  67         mutex_lock(&indio_dev->mlock);
  68         info->conv_mode = mode;
  69         val = readl(info->regs + VF610_DACx_STATCTRL);
  70         if (mode)
  71                 val |= VF610_DAC_LPEN;
  72         else
  73                 val &= ~VF610_DAC_LPEN;
  74         writel(val, info->regs + VF610_DACx_STATCTRL);
  75         mutex_unlock(&indio_dev->mlock);
  76
  77         return 0;
  78 }
  79
  80 static int vf610_get_conversion_mode(struct iio_dev *indio_dev,
  81                                 const struct iio_chan_spec *chan)
  82 {
  83         struct vf610_dac *info = iio_priv(indio_dev);
  84
  85         return info->conv_mode;
  86 }
  87
  88 static const char * const vf610_conv_modes[] = { "high-power", "low-power" };
  89
  90 static const struct iio_enum vf610_conversion_mode = {
  91         .items = vf610_conv_modes,
  92         .num_items = ARRAY_SIZE(vf610_conv_modes),
  93         .get = vf610_get_conversion_mode,
  94         .set = vf610_set_conversion_mode,
  95 };
  96
  97 static const struct iio_chan_spec_ext_info vf610_ext_info[] = {
  98         IIO_ENUM("conversion_mode", IIO_SHARED_BY_DIR,
  99                 &vf610_conversion_mode),
 100         {},
 101 };
 102
 103 #define VF610_DAC_CHAN(_chan_type) { \
 104         .type = (_chan_type), \
 105         .output = 1, \
 106         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
 107         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
 108         .ext_info = vf610_ext_info, \
 109 }
 110
 111 static const struct iio_chan_spec vf610_dac_iio_channels[] = {
 112         VF610_DAC_CHAN(IIO_VOLTAGE),
 113 };
 114
 115 static int vf610_read_raw(struct iio_dev *indio_dev,
 116                         struct iio_chan_spec const *chan,
 117                         int *val, int *val2,
 118                         long mask)
 119 {
 120         struct vf610_dac *info = iio_priv(indio_dev);
 121
 122         switch (mask) {
 123         case IIO_CHAN_INFO_RAW:
 124                 *val = VF610_DAC_DAT0(readl(info->regs));
 125                 return IIO_VAL_INT;
 126         case IIO_CHAN_INFO_SCALE:
 127                 /*
 128                  * DACRFS is always 1 for valid reference and typical
 129                  * reference voltage as per Vybrid datasheet is 3.3V
 130                  * from section 9.1.2.1 of Vybrid datasheet
 131                  */
 132                 *val = 3300 /* mV */;
 133                 *val2 = 12;
 134                 return IIO_VAL_FRACTIONAL_LOG2;
 135
 136         default:
 137                 return -EINVAL;
 138         }
 139 }
 140
 141 static int vf610_write_raw(struct iio_dev *indio_dev,
 142                         struct iio_chan_spec const *chan,
 143                         int val, int val2,
 144                         long mask)
 145 {
 146         struct vf610_dac *info = iio_priv(indio_dev);
 147
 148         switch (mask) {
 149         case IIO_CHAN_INFO_RAW:
 150                 mutex_lock(&indio_dev->mlock);
 151                 writel(VF610_DAC_DAT0(val), info->regs);
 152                 mutex_unlock(&indio_dev->mlock);
 153                 return 0;
 154
 155         default:
 156                 return -EINVAL;
 157         }
 158 }
 159
 160 static const struct iio_info vf610_dac_iio_info = {
 161         .read_raw = &vf610_read_raw,
 162         .write_raw = &vf610_write_raw,
 163 };
 164
 165 static const struct of_device_id vf610_dac_match[] = {
 166         { .compatible = "fsl,vf610-dac", },
 167         { /* sentinel */ }
 168 };
 169 MODULE_DEVICE_TABLE(of, vf610_dac_match);
 170
 171 static int vf610_dac_probe(struct platform_device *pdev)
 172 {
 173         struct iio_dev *indio_dev;
 174         struct vf610_dac *info;
 175         int ret;
 176
 177         indio_dev = devm_iio_device_alloc(&pdev->dev,
 178                                         sizeof(struct vf610_dac));
 179         if (!indio_dev) {
 180                 dev_err(&pdev->dev, "Failed allocating iio device\n");
 181                 return -ENOMEM;
 182         }
 183
 184         info = iio_priv(indio_dev);
 185         info->dev = &pdev->dev;
 186
 187         info->regs = devm_platform_ioremap_resource(pdev, 0);
 188         if (IS_ERR(info->regs))
 189                 return PTR_ERR(info->regs);
 190
 191         info->clk = devm_clk_get(&pdev->dev, "dac");
 192         if (IS_ERR(info->clk)) {
 193                 dev_err(&pdev->dev, "Failed getting clock, err = %ld\n",
 194                         PTR_ERR(info->clk));
 195                 return PTR_ERR(info->clk);
 196         }
 197
 198         platform_set_drvdata(pdev, indio_dev);
 199
 200         indio_dev->name = dev_name(&pdev->dev);
 201         indio_dev->dev.parent = &pdev->dev;
 202         indio_dev->dev.of_node = pdev->dev.of_node;
 203         indio_dev->info = &vf610_dac_iio_info;
 204         indio_dev->modes = INDIO_DIRECT_MODE;
 205         indio_dev->channels = vf610_dac_iio_channels;
 206         indio_dev->num_channels = ARRAY_SIZE(vf610_dac_iio_channels);
 207
 208         ret = clk_prepare_enable(info->clk);
 209         if (ret) {
 210                 dev_err(&pdev->dev,
 211                         "Could not prepare or enable the clock\n");
 212                 return ret;
 213         }
 214
 215         vf610_dac_init(info);
 216
 217         ret = iio_device_register(indio_dev);
 218         if (ret) {
 219                 dev_err(&pdev->dev, "Couldn't register the device\n");
 220                 goto error_iio_device_register;
 221         }
 222
 223         return 0;
 224
 225 error_iio_device_register:
 226         vf610_dac_exit(info);
 227         clk_disable_unprepare(info->clk);
 228
 229         return ret;
 230 }
 231
 232 static int vf610_dac_remove(struct platform_device *pdev)
 233 {
 234         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 235         struct vf610_dac *info = iio_priv(indio_dev);
 236
 237         iio_device_unregister(indio_dev);
 238         vf610_dac_exit(info);
 239         clk_disable_unprepare(info->clk);
 240
 241         return 0;
 242 }
 243
 244 #ifdef CONFIG_PM_SLEEP
 245 static int vf610_dac_suspend(struct device *dev)
 246 {
 247         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 248         struct vf610_dac *info = iio_priv(indio_dev);
 249
 250         vf610_dac_exit(info);
 251         clk_disable_unprepare(info->clk);
 252
 253         return 0;
 254 }
 255
 256 static int vf610_dac_resume(struct device *dev)
 257 {
 258         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 259         struct vf610_dac *info = iio_priv(indio_dev);
 260         int ret;
 261
 262         ret = clk_prepare_enable(info->clk);
 263         if (ret)
 264                 return ret;
 265
 266         vf610_dac_init(info);
 267
 268         return 0;
 269 }
 270 #endif
 271
 272 static SIMPLE_DEV_PM_OPS(vf610_dac_pm_ops, vf610_dac_suspend, vf610_dac_resume);
 273
 274 static struct platform_driver vf610_dac_driver = {
 275         .probe          = vf610_dac_probe,
 276         .remove         = vf610_dac_remove,
 277         .driver         = {
 278                 .name   = "vf610-dac",
 279                 .of_match_table = vf610_dac_match,
 280                 .pm     = &vf610_dac_pm_ops,
 281         },
 282 };
 283 module_platform_driver(vf610_dac_driver);
 284
 285 MODULE_AUTHOR("Sanchayan Maity <sanchayan.maity@toradex.com>");
 286 MODULE_DESCRIPTION("Freescale VF610 DAC driver");
 287 MODULE_LICENSE("GPL v2");