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