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         struct resource *mem;
 176         int ret;
 177
 178         indio_dev = devm_iio_device_alloc(&pdev->dev,
 179                                         sizeof(struct vf610_dac));
 180         if (!indio_dev) {
 181                 dev_err(&pdev->dev, "Failed allocating iio device\n");
 182                 return -ENOMEM;
 183         }
 184
 185         info = iio_priv(indio_dev);
 186         info->dev = &pdev->dev;
 187
 188         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 189         info->regs = devm_ioremap_resource(&pdev->dev, mem);
 190         if (IS_ERR(info->regs))
 191                 return PTR_ERR(info->regs);
 192
 193         info->clk = devm_clk_get(&pdev->dev, "dac");
 194         if (IS_ERR(info->clk)) {
 195                 dev_err(&pdev->dev, "Failed getting clock, err = %ld\n",
 196                         PTR_ERR(info->clk));
 197                 return PTR_ERR(info->clk);
 198         }
 199
 200         platform_set_drvdata(pdev, indio_dev);
 201
 202         indio_dev->name = dev_name(&pdev->dev);
 203         indio_dev->dev.parent = &pdev->dev;
 204         indio_dev->dev.of_node = pdev->dev.of_node;
 205         indio_dev->info = &vf610_dac_iio_info;
 206         indio_dev->modes = INDIO_DIRECT_MODE;
 207         indio_dev->channels = vf610_dac_iio_channels;
 208         indio_dev->num_channels = ARRAY_SIZE(vf610_dac_iio_channels);
 209
 210         ret = clk_prepare_enable(info->clk);
 211         if (ret) {
 212                 dev_err(&pdev->dev,
 213                         "Could not prepare or enable the clock\n");
 214                 return ret;
 215         }
 216
 217         vf610_dac_init(info);
 218
 219         ret = iio_device_register(indio_dev);
 220         if (ret) {
 221                 dev_err(&pdev->dev, "Couldn't register the device\n");
 222                 goto error_iio_device_register;
 223         }
 224
 225         return 0;
 226
 227 error_iio_device_register:
 228         clk_disable_unprepare(info->clk);
 229
 230         return ret;
 231 }
 232
 233 static int vf610_dac_remove(struct platform_device *pdev)
 234 {
 235         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 236         struct vf610_dac *info = iio_priv(indio_dev);
 237
 238         iio_device_unregister(indio_dev);
 239         vf610_dac_exit(info);
 240         clk_disable_unprepare(info->clk);
 241
 242         return 0;
 243 }
 244
 245 #ifdef CONFIG_PM_SLEEP
 246 static int vf610_dac_suspend(struct device *dev)
 247 {
 248         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 249         struct vf610_dac *info = iio_priv(indio_dev);
 250
 251         vf610_dac_exit(info);
 252         clk_disable_unprepare(info->clk);
 253
 254         return 0;
 255 }
 256
 257 static int vf610_dac_resume(struct device *dev)
 258 {
 259         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 260         struct vf610_dac *info = iio_priv(indio_dev);
 261         int ret;
 262
 263         ret = clk_prepare_enable(info->clk);
 264         if (ret)
 265                 return ret;
 266
 267         vf610_dac_init(info);
 268
 269         return 0;
 270 }
 271 #endif
 272
 273 static SIMPLE_DEV_PM_OPS(vf610_dac_pm_ops, vf610_dac_suspend, vf610_dac_resume);
 274
 275 static struct platform_driver vf610_dac_driver = {
 276         .probe          = vf610_dac_probe,
 277         .remove         = vf610_dac_remove,
 278         .driver         = {
 279                 .name   = "vf610-dac",
 280                 .of_match_table = vf610_dac_match,
 281                 .pm     = &vf610_dac_pm_ops,
 282         },
 283 };
 284 module_platform_driver(vf610_dac_driver);
 285
 286 MODULE_AUTHOR("Sanchayan Maity <sanchayan.maity@toradex.com>");
 287 MODULE_DESCRIPTION("Freescale VF610 DAC driver");
 288 MODULE_LICENSE("GPL v2");