435 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * ti-dac5571.c - Texas Instruments 8/10/12-bit 1/4-channel DAC driver4 *5 * Copyright (C) 2018 Prevas A/S6 *7 * https://www.ti.com/lit/ds/symlink/dac5571.pdf8 * https://www.ti.com/lit/ds/symlink/dac6571.pdf9 * https://www.ti.com/lit/ds/symlink/dac7571.pdf10 * https://www.ti.com/lit/ds/symlink/dac5574.pdf11 * https://www.ti.com/lit/ds/symlink/dac6574.pdf12 * https://www.ti.com/lit/ds/symlink/dac7574.pdf13 * https://www.ti.com/lit/ds/symlink/dac5573.pdf14 * https://www.ti.com/lit/ds/symlink/dac6573.pdf15 * https://www.ti.com/lit/ds/symlink/dac7573.pdf16 * https://www.ti.com/lit/ds/symlink/dac081c081.pdf17 * https://www.ti.com/lit/ds/symlink/dac121c081.pdf18 */19 20#include <linux/iio/iio.h>21#include <linux/i2c.h>22#include <linux/module.h>23#include <linux/mod_devicetable.h>24#include <linux/property.h>25#include <linux/regulator/consumer.h>26 27enum chip_id {28 single_8bit, single_10bit, single_12bit,29 quad_8bit, quad_10bit, quad_12bit30};31 32struct dac5571_spec {33 u8 num_channels;34 u8 resolution;35};36 37static const struct dac5571_spec dac5571_spec[] = {38 [single_8bit] = {.num_channels = 1, .resolution = 8},39 [single_10bit] = {.num_channels = 1, .resolution = 10},40 [single_12bit] = {.num_channels = 1, .resolution = 12},41 [quad_8bit] = {.num_channels = 4, .resolution = 8},42 [quad_10bit] = {.num_channels = 4, .resolution = 10},43 [quad_12bit] = {.num_channels = 4, .resolution = 12},44};45 46struct dac5571_data {47 struct i2c_client *client;48 int id;49 struct mutex lock;50 struct regulator *vref;51 u16 val[4];52 bool powerdown[4];53 u8 powerdown_mode[4];54 struct dac5571_spec const *spec;55 int (*dac5571_cmd)(struct dac5571_data *data, int channel, u16 val);56 int (*dac5571_pwrdwn)(struct dac5571_data *data, int channel, u8 pwrdwn);57 u8 buf[3] __aligned(IIO_DMA_MINALIGN);58};59 60#define DAC5571_POWERDOWN(mode) ((mode) + 1)61#define DAC5571_POWERDOWN_FLAG BIT(0)62#define DAC5571_CHANNEL_SELECT 163#define DAC5571_LOADMODE_DIRECT BIT(4)64#define DAC5571_SINGLE_PWRDWN_BITS 465#define DAC5571_QUAD_PWRDWN_BITS 666 67static int dac5571_cmd_single(struct dac5571_data *data, int channel, u16 val)68{69 unsigned int shift;70 71 shift = 12 - data->spec->resolution;72 data->buf[1] = val << shift;73 data->buf[0] = val >> (8 - shift);74 75 if (i2c_master_send(data->client, data->buf, 2) != 2)76 return -EIO;77 78 return 0;79}80 81static int dac5571_cmd_quad(struct dac5571_data *data, int channel, u16 val)82{83 unsigned int shift;84 85 shift = 16 - data->spec->resolution;86 data->buf[2] = val << shift;87 data->buf[1] = (val >> (8 - shift));88 data->buf[0] = (channel << DAC5571_CHANNEL_SELECT) |89 DAC5571_LOADMODE_DIRECT;90 91 if (i2c_master_send(data->client, data->buf, 3) != 3)92 return -EIO;93 94 return 0;95}96 97static int dac5571_pwrdwn_single(struct dac5571_data *data, int channel, u8 pwrdwn)98{99 data->buf[1] = 0;100 data->buf[0] = pwrdwn << DAC5571_SINGLE_PWRDWN_BITS;101 102 if (i2c_master_send(data->client, data->buf, 2) != 2)103 return -EIO;104 105 return 0;106}107 108static int dac5571_pwrdwn_quad(struct dac5571_data *data, int channel, u8 pwrdwn)109{110 data->buf[2] = 0;111 data->buf[1] = pwrdwn << DAC5571_QUAD_PWRDWN_BITS;112 data->buf[0] = (channel << DAC5571_CHANNEL_SELECT) |113 DAC5571_LOADMODE_DIRECT | DAC5571_POWERDOWN_FLAG;114 115 if (i2c_master_send(data->client, data->buf, 3) != 3)116 return -EIO;117 118 return 0;119}120 121static const char *const dac5571_powerdown_modes[] = {122 "1kohm_to_gnd", "100kohm_to_gnd", "three_state",123};124 125static int dac5571_get_powerdown_mode(struct iio_dev *indio_dev,126 const struct iio_chan_spec *chan)127{128 struct dac5571_data *data = iio_priv(indio_dev);129 130 return data->powerdown_mode[chan->channel];131}132 133static int dac5571_set_powerdown_mode(struct iio_dev *indio_dev,134 const struct iio_chan_spec *chan,135 unsigned int mode)136{137 struct dac5571_data *data = iio_priv(indio_dev);138 int ret = 0;139 140 if (data->powerdown_mode[chan->channel] == mode)141 return 0;142 143 mutex_lock(&data->lock);144 if (data->powerdown[chan->channel]) {145 ret = data->dac5571_pwrdwn(data, chan->channel,146 DAC5571_POWERDOWN(mode));147 if (ret)148 goto out;149 }150 data->powerdown_mode[chan->channel] = mode;151 152 out:153 mutex_unlock(&data->lock);154 155 return ret;156}157 158static const struct iio_enum dac5571_powerdown_mode = {159 .items = dac5571_powerdown_modes,160 .num_items = ARRAY_SIZE(dac5571_powerdown_modes),161 .get = dac5571_get_powerdown_mode,162 .set = dac5571_set_powerdown_mode,163};164 165static ssize_t dac5571_read_powerdown(struct iio_dev *indio_dev,166 uintptr_t private,167 const struct iio_chan_spec *chan,168 char *buf)169{170 struct dac5571_data *data = iio_priv(indio_dev);171 172 return sysfs_emit(buf, "%d\n", data->powerdown[chan->channel]);173}174 175static ssize_t dac5571_write_powerdown(struct iio_dev *indio_dev,176 uintptr_t private,177 const struct iio_chan_spec *chan,178 const char *buf, size_t len)179{180 struct dac5571_data *data = iio_priv(indio_dev);181 bool powerdown;182 int ret;183 184 ret = kstrtobool(buf, &powerdown);185 if (ret)186 return ret;187 188 if (data->powerdown[chan->channel] == powerdown)189 return len;190 191 mutex_lock(&data->lock);192 if (powerdown)193 ret = data->dac5571_pwrdwn(data, chan->channel,194 DAC5571_POWERDOWN(data->powerdown_mode[chan->channel]));195 else196 ret = data->dac5571_cmd(data, chan->channel,197 data->val[chan->channel]);198 if (ret)199 goto out;200 201 data->powerdown[chan->channel] = powerdown;202 203 out:204 mutex_unlock(&data->lock);205 206 return ret ? ret : len;207}208 209 210static const struct iio_chan_spec_ext_info dac5571_ext_info[] = {211 {212 .name = "powerdown",213 .read = dac5571_read_powerdown,214 .write = dac5571_write_powerdown,215 .shared = IIO_SEPARATE,216 },217 IIO_ENUM("powerdown_mode", IIO_SEPARATE, &dac5571_powerdown_mode),218 IIO_ENUM_AVAILABLE("powerdown_mode", IIO_SHARED_BY_TYPE, &dac5571_powerdown_mode),219 {},220};221 222#define dac5571_CHANNEL(chan, name) { \223 .type = IIO_VOLTAGE, \224 .channel = (chan), \225 .address = (chan), \226 .indexed = true, \227 .output = true, \228 .datasheet_name = name, \229 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \230 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \231 .ext_info = dac5571_ext_info, \232}233 234static const struct iio_chan_spec dac5571_channels[] = {235 dac5571_CHANNEL(0, "A"),236 dac5571_CHANNEL(1, "B"),237 dac5571_CHANNEL(2, "C"),238 dac5571_CHANNEL(3, "D"),239};240 241static int dac5571_read_raw(struct iio_dev *indio_dev,242 struct iio_chan_spec const *chan,243 int *val, int *val2, long mask)244{245 struct dac5571_data *data = iio_priv(indio_dev);246 int ret;247 248 switch (mask) {249 case IIO_CHAN_INFO_RAW:250 *val = data->val[chan->channel];251 return IIO_VAL_INT;252 253 case IIO_CHAN_INFO_SCALE:254 ret = regulator_get_voltage(data->vref);255 if (ret < 0)256 return ret;257 258 *val = ret / 1000;259 *val2 = data->spec->resolution;260 return IIO_VAL_FRACTIONAL_LOG2;261 262 default:263 return -EINVAL;264 }265}266 267static int dac5571_write_raw(struct iio_dev *indio_dev,268 struct iio_chan_spec const *chan,269 int val, int val2, long mask)270{271 struct dac5571_data *data = iio_priv(indio_dev);272 int ret;273 274 switch (mask) {275 case IIO_CHAN_INFO_RAW:276 if (data->val[chan->channel] == val)277 return 0;278 279 if (val >= (1 << data->spec->resolution) || val < 0)280 return -EINVAL;281 282 if (data->powerdown[chan->channel])283 return -EBUSY;284 285 mutex_lock(&data->lock);286 ret = data->dac5571_cmd(data, chan->channel, val);287 if (ret == 0)288 data->val[chan->channel] = val;289 mutex_unlock(&data->lock);290 return ret;291 292 default:293 return -EINVAL;294 }295}296 297static int dac5571_write_raw_get_fmt(struct iio_dev *indio_dev,298 struct iio_chan_spec const *chan,299 long mask)300{301 return IIO_VAL_INT;302}303 304static const struct iio_info dac5571_info = {305 .read_raw = dac5571_read_raw,306 .write_raw = dac5571_write_raw,307 .write_raw_get_fmt = dac5571_write_raw_get_fmt,308};309 310static int dac5571_probe(struct i2c_client *client)311{312 const struct i2c_device_id *id = i2c_client_get_device_id(client);313 struct device *dev = &client->dev;314 const struct dac5571_spec *spec;315 struct dac5571_data *data;316 struct iio_dev *indio_dev;317 int ret, i;318 319 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));320 if (!indio_dev)321 return -ENOMEM;322 323 data = iio_priv(indio_dev);324 i2c_set_clientdata(client, indio_dev);325 data->client = client;326 327 indio_dev->info = &dac5571_info;328 indio_dev->name = id->name;329 indio_dev->modes = INDIO_DIRECT_MODE;330 indio_dev->channels = dac5571_channels;331 332 spec = i2c_get_match_data(client);333 334 indio_dev->num_channels = spec->num_channels;335 data->spec = spec;336 337 data->vref = devm_regulator_get(dev, "vref");338 if (IS_ERR(data->vref))339 return PTR_ERR(data->vref);340 341 ret = regulator_enable(data->vref);342 if (ret < 0)343 return ret;344 345 mutex_init(&data->lock);346 347 switch (spec->num_channels) {348 case 1:349 data->dac5571_cmd = dac5571_cmd_single;350 data->dac5571_pwrdwn = dac5571_pwrdwn_single;351 break;352 case 4:353 data->dac5571_cmd = dac5571_cmd_quad;354 data->dac5571_pwrdwn = dac5571_pwrdwn_quad;355 break;356 default:357 ret = -EINVAL;358 goto err;359 }360 361 for (i = 0; i < spec->num_channels; i++) {362 ret = data->dac5571_cmd(data, i, 0);363 if (ret) {364 dev_err(dev, "failed to initialize channel %d to 0\n", i);365 goto err;366 }367 }368 369 ret = iio_device_register(indio_dev);370 if (ret)371 goto err;372 373 return 0;374 375 err:376 regulator_disable(data->vref);377 return ret;378}379 380static void dac5571_remove(struct i2c_client *i2c)381{382 struct iio_dev *indio_dev = i2c_get_clientdata(i2c);383 struct dac5571_data *data = iio_priv(indio_dev);384 385 iio_device_unregister(indio_dev);386 regulator_disable(data->vref);387}388 389static const struct of_device_id dac5571_of_id[] = {390 {.compatible = "ti,dac081c081", .data = &dac5571_spec[single_8bit] },391 {.compatible = "ti,dac121c081", .data = &dac5571_spec[single_12bit] },392 {.compatible = "ti,dac5571", .data = &dac5571_spec[single_8bit] },393 {.compatible = "ti,dac6571", .data = &dac5571_spec[single_10bit] },394 {.compatible = "ti,dac7571", .data = &dac5571_spec[single_12bit] },395 {.compatible = "ti,dac5574", .data = &dac5571_spec[quad_8bit] },396 {.compatible = "ti,dac6574", .data = &dac5571_spec[quad_10bit] },397 {.compatible = "ti,dac7574", .data = &dac5571_spec[quad_12bit] },398 {.compatible = "ti,dac5573", .data = &dac5571_spec[quad_8bit] },399 {.compatible = "ti,dac6573", .data = &dac5571_spec[quad_10bit] },400 {.compatible = "ti,dac7573", .data = &dac5571_spec[quad_12bit] },401 {}402};403MODULE_DEVICE_TABLE(of, dac5571_of_id);404 405static const struct i2c_device_id dac5571_id[] = {406 {"dac081c081", (kernel_ulong_t)&dac5571_spec[single_8bit] },407 {"dac121c081", (kernel_ulong_t)&dac5571_spec[single_12bit] },408 {"dac5571", (kernel_ulong_t)&dac5571_spec[single_8bit] },409 {"dac6571", (kernel_ulong_t)&dac5571_spec[single_10bit] },410 {"dac7571", (kernel_ulong_t)&dac5571_spec[single_12bit] },411 {"dac5574", (kernel_ulong_t)&dac5571_spec[quad_8bit] },412 {"dac6574", (kernel_ulong_t)&dac5571_spec[quad_10bit] },413 {"dac7574", (kernel_ulong_t)&dac5571_spec[quad_12bit] },414 {"dac5573", (kernel_ulong_t)&dac5571_spec[quad_8bit] },415 {"dac6573", (kernel_ulong_t)&dac5571_spec[quad_10bit] },416 {"dac7573", (kernel_ulong_t)&dac5571_spec[quad_12bit] },417 {}418};419MODULE_DEVICE_TABLE(i2c, dac5571_id);420 421static struct i2c_driver dac5571_driver = {422 .driver = {423 .name = "ti-dac5571",424 .of_match_table = dac5571_of_id,425 },426 .probe = dac5571_probe,427 .remove = dac5571_remove,428 .id_table = dac5571_id,429};430module_i2c_driver(dac5571_driver);431 432MODULE_AUTHOR("Sean Nyekjaer <sean@geanix.dk>");433MODULE_DESCRIPTION("Texas Instruments 8/10/12-bit 1/4-channel DAC driver");434MODULE_LICENSE("GPL v2");435