linux-kernel/linux-7.2.3/drivers/iio/dac/ds4424.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Maxim Integrated
 * 7-bit, Multi-Channel Sink/Source Current DAC Driver
 * Copyright (C) 2017 Maxim Integrated
 */

#include <linux/array_size.h>
#include <linux/bits.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/property.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <linux/time64.h>
#include <linux/types.h>

#include <linux/iio/driver.h>
#include <linux/iio/iio.h>
#include <linux/iio/machine.h>

#define DS4422_MAX_DAC_CHANNELS		2
#define DS4424_MAX_DAC_CHANNELS		4

#define DS4424_DAC_MASK			GENMASK(6, 0)
#define DS4404_DAC_MASK			GENMASK(4, 0)
#define DS4424_DAC_SOURCE		BIT(7)

#define DS4424_DAC_ADDR(chan)   ((chan) + 0xf8)

#define DS4424_CHANNEL(chan) { \
	.type = IIO_CURRENT, \
	.indexed = 1, \
	.output = 1, \
	.channel = chan, \
	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
}

#define DS4424_CHANNEL_WITH_SCALE(chan) { \
	.type = IIO_CURRENT, \
	.indexed = 1, \
	.output = 1, \
	.channel = chan, \
	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
			      BIT(IIO_CHAN_INFO_SCALE), \
}

struct ds4424_chip_info {
	const char *name;
	int vref_mV;
	int scale_denom;
	u8 result_mask;
	u8 num_channels;
};

static const struct ds4424_chip_info ds4402_info = {
	.name = "ds4402",
	.vref_mV = 1230,
	.scale_denom = 4,
	.result_mask = DS4404_DAC_MASK,
	.num_channels = DS4422_MAX_DAC_CHANNELS,
};

static const struct ds4424_chip_info ds4404_info = {
	.name = "ds4404",
	.vref_mV = 1230,
	.scale_denom = 4,
	.result_mask = DS4404_DAC_MASK,
	.num_channels = DS4424_MAX_DAC_CHANNELS,
};

static const struct ds4424_chip_info ds4422_info = {
	.name = "ds4422",
	.vref_mV = 976,
	.scale_denom = 16,
	.result_mask = DS4424_DAC_MASK,
	.num_channels = DS4422_MAX_DAC_CHANNELS,
};

static const struct ds4424_chip_info ds4424_info = {
	.name = "ds4424",
	.vref_mV = 976,
	.scale_denom = 16,
	.result_mask = DS4424_DAC_MASK,
	.num_channels = DS4424_MAX_DAC_CHANNELS,
};

struct ds4424_data {
	struct regmap *regmap;
	struct regulator *vcc_reg;
	const struct ds4424_chip_info *chip_info;
	u32 rfs_ohms[DS4424_MAX_DAC_CHANNELS];
	bool has_rfs;
};

static const struct iio_chan_spec ds4424_channels[] = {
	DS4424_CHANNEL(0),
	DS4424_CHANNEL(1),
	DS4424_CHANNEL(2),
	DS4424_CHANNEL(3),
};

static const struct iio_chan_spec ds4424_channels_with_scale[] = {
	DS4424_CHANNEL_WITH_SCALE(0),
	DS4424_CHANNEL_WITH_SCALE(1),
	DS4424_CHANNEL_WITH_SCALE(2),
	DS4424_CHANNEL_WITH_SCALE(3),
};

static const struct regmap_range ds44x2_ranges[] = {
	regmap_reg_range(DS4424_DAC_ADDR(0), DS4424_DAC_ADDR(1)),
};

static const struct regmap_range ds44x4_ranges[] = {
	regmap_reg_range(DS4424_DAC_ADDR(0), DS4424_DAC_ADDR(3)),
};

static const struct regmap_access_table ds44x2_table = {
	.yes_ranges = ds44x2_ranges,
	.n_yes_ranges = ARRAY_SIZE(ds44x2_ranges),
};

static const struct regmap_access_table ds44x4_table = {
	.yes_ranges = ds44x4_ranges,
	.n_yes_ranges = ARRAY_SIZE(ds44x4_ranges),
};

static const struct regmap_config ds44x2_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.cache_type = REGCACHE_MAPLE,
	.max_register = DS4424_DAC_ADDR(1),
	.rd_table = &ds44x2_table,
	.wr_table = &ds44x2_table,
};

static const struct regmap_config ds44x4_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.cache_type = REGCACHE_MAPLE,
	.max_register = DS4424_DAC_ADDR(3),
	.rd_table = &ds44x4_table,
	.wr_table = &ds44x4_table,
};

static int ds4424_init_regmap(struct i2c_client *client,
			      struct iio_dev *indio_dev)
{
	struct ds4424_data *data = iio_priv(indio_dev);
	const struct regmap_config *regmap_config;
	u8 vals[DS4424_MAX_DAC_CHANNELS];
	int ret;

	if (indio_dev->num_channels == DS4424_MAX_DAC_CHANNELS)
		regmap_config = &ds44x4_regmap_config;
	else
		regmap_config = &ds44x2_regmap_config;

	data->regmap = devm_regmap_init_i2c(client, regmap_config);
	if (IS_ERR(data->regmap))
		return dev_err_probe(&client->dev, PTR_ERR(data->regmap),
				     "Failed to init regmap.\n");

	/*
	 * Prime the cache with the bootloader's configuration.
	 * regmap_bulk_read() will automatically populate the cache with
	 * the values read from the hardware.
	 */
	ret = regmap_bulk_read(data->regmap, DS4424_DAC_ADDR(0), vals,
			       indio_dev->num_channels);
	if (ret)
		return dev_err_probe(&client->dev, ret,
				     "Failed to read hardware values\n");

	return 0;
}

static int ds4424_read_raw(struct iio_dev *indio_dev,
			   struct iio_chan_spec const *chan,
			   int *val, int *val2, long mask)
{
	struct ds4424_data *data = iio_priv(indio_dev);
	unsigned int regval;
	int ret;

	switch (mask) {
	case IIO_CHAN_INFO_RAW:
		ret = regmap_read(data->regmap, DS4424_DAC_ADDR(chan->channel),
				  &regval);
		if (ret < 0) {
			dev_err_ratelimited(indio_dev->dev.parent,
					    "Failed to read channel %d: %pe\n",
					    chan->channel, ERR_PTR(ret));
			return ret;
		}

		*val = regval & data->chip_info->result_mask;
		if (!(regval & DS4424_DAC_SOURCE))
			*val = -*val;

		return IIO_VAL_INT;
	case IIO_CHAN_INFO_SCALE:
		if (!data->has_rfs)
			return -EINVAL;

		/* SCALE is mA/step: mV / Ohm = mA. */
		*val = data->chip_info->vref_mV;
		*val2 = data->rfs_ohms[chan->channel] *
			data->chip_info->scale_denom;
		return IIO_VAL_FRACTIONAL;

	default:
		return -EINVAL;
	}
}

static int ds4424_write_raw(struct iio_dev *indio_dev,
			     struct iio_chan_spec const *chan,
			     int val, int val2, long mask)
{
	struct ds4424_data *data = iio_priv(indio_dev);
	unsigned int abs_val;

	if (val2 != 0)
		return -EINVAL;

	switch (mask) {
	case IIO_CHAN_INFO_RAW:
		abs_val = abs(val);
		if (abs_val > data->chip_info->result_mask)
			return -EINVAL;

		/*
		 * Currents exiting the IC (Source) are positive. 0 is a valid
		 * value for no current flow; the direction bit (Source vs Sink)
		 * is treated as don't-care by the hardware at 0.
		 */
		if (val > 0)
			abs_val |= DS4424_DAC_SOURCE;

		return regmap_write(data->regmap, DS4424_DAC_ADDR(chan->channel),
				    abs_val);

	default:
		return -EINVAL;
	}
}

static int ds4424_parse_rfs(struct i2c_client *client,
			    struct ds4424_data *data,
			    struct iio_dev *indio_dev)
{
	struct device *dev = &client->dev;
	int count, ret;

	if (!device_property_present(dev, "maxim,rfs-ohms"))
		return 0;

	count = device_property_count_u32(dev, "maxim,rfs-ohms");
	if (count < 0)
		return dev_err_probe(dev, count, "Failed to count maxim,rfs-ohms entries\n");
	if (count != indio_dev->num_channels)
		return dev_err_probe(dev, -EINVAL, "maxim,rfs-ohms must have %u entries\n",
				     indio_dev->num_channels);

	ret = device_property_read_u32_array(dev, "maxim,rfs-ohms",
					     data->rfs_ohms,
					     indio_dev->num_channels);
	if (ret)
		return dev_err_probe(dev, ret, "Failed to read maxim,rfs-ohms property\n");

	for (unsigned int i = 0; i < indio_dev->num_channels; i++) {
		if (!data->rfs_ohms[i])
			return dev_err_probe(dev, -EINVAL, "maxim,rfs-ohms entry %u is zero\n", i);
	}

	data->has_rfs = true;

	return 0;
}

static int ds4424_suspend(struct device *dev)
{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct ds4424_data *data = iio_priv(indio_dev);
	u8 zero_buf[DS4424_MAX_DAC_CHANNELS] = { };
	int ret;

	/* Disable all outputs, bypass cache so the '0' isn't saved */
	regcache_cache_bypass(data->regmap, true);
	ret = regmap_bulk_write(data->regmap, DS4424_DAC_ADDR(0),
				zero_buf, indio_dev->num_channels);
	regcache_cache_bypass(data->regmap, false);
	if (ret) {
		dev_err(dev, "Failed to zero outputs: %pe\n", ERR_PTR(ret));
		return ret;
	}

	regcache_cache_only(data->regmap, true);
	regcache_mark_dirty(data->regmap);

	return 0;
}

static int ds4424_resume(struct device *dev)
{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct ds4424_data *data = iio_priv(indio_dev);

	regcache_cache_only(data->regmap, false);
	return regcache_sync(data->regmap);
}

static DEFINE_SIMPLE_DEV_PM_OPS(ds4424_pm_ops, ds4424_suspend, ds4424_resume);

static const struct iio_info ds4424_iio_info = {
	.read_raw = ds4424_read_raw,
	.write_raw = ds4424_write_raw,
};

static int ds4424_probe(struct i2c_client *client)
{
	const struct ds4424_chip_info *chip_info;
	struct ds4424_data *data;
	struct iio_dev *indio_dev;
	int ret;

	chip_info = i2c_get_match_data(client);
	if (!chip_info)
		return -ENODEV;

	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
	if (!indio_dev)
		return -ENOMEM;

	data = iio_priv(indio_dev);
	i2c_set_clientdata(client, indio_dev);
	indio_dev->name = chip_info->name;
	data->chip_info = chip_info;

	data->vcc_reg = devm_regulator_get(&client->dev, "vcc");
	if (IS_ERR(data->vcc_reg))
		return dev_err_probe(&client->dev, PTR_ERR(data->vcc_reg),
				     "Failed to get vcc-supply regulator.\n");

	ret = regulator_enable(data->vcc_reg);
	if (ret < 0) {
		dev_err(&client->dev,
				"Unable to enable the regulator.\n");
		return ret;
	}

	/*
	 * The datasheet does not specify a power-up to I2C ready time.
	 * Maintain the existing conservative 1ms delay to ensure the
	 * device is ready for communication.
	 */
	fsleep(1 * USEC_PER_MSEC);

	indio_dev->num_channels = chip_info->num_channels;
	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->info = &ds4424_iio_info;

	ret = ds4424_init_regmap(client, indio_dev);
	if (ret)
		goto fail;

	ret = ds4424_parse_rfs(client, data, indio_dev);
	if (ret)
		goto fail;

	if (data->has_rfs)
		indio_dev->channels = ds4424_channels_with_scale;
	else
		indio_dev->channels = ds4424_channels;

	ret = iio_device_register(indio_dev);
	if (ret < 0) {
		dev_err(&client->dev,
				"iio_device_register failed. ret: %d\n", ret);
		goto fail;
	}

	return ret;

fail:
	regulator_disable(data->vcc_reg);
	return ret;
}

static void ds4424_remove(struct i2c_client *client)
{
	struct iio_dev *indio_dev = i2c_get_clientdata(client);
	struct ds4424_data *data = iio_priv(indio_dev);

	iio_device_unregister(indio_dev);
	regulator_disable(data->vcc_reg);
}

static const struct i2c_device_id ds4424_id[] = {
	{ .name = "ds4402", .driver_data = (kernel_ulong_t)&ds4402_info },
	{ .name = "ds4404", .driver_data = (kernel_ulong_t)&ds4404_info },
	{ .name = "ds4422", .driver_data = (kernel_ulong_t)&ds4422_info },
	{ .name = "ds4424", .driver_data = (kernel_ulong_t)&ds4424_info },
	{ }
};

MODULE_DEVICE_TABLE(i2c, ds4424_id);

static const struct of_device_id ds4424_of_match[] = {
	{ .compatible = "maxim,ds4402", .data = &ds4402_info },
	{ .compatible = "maxim,ds4404", .data = &ds4404_info },
	{ .compatible = "maxim,ds4422", .data = &ds4422_info },
	{ .compatible = "maxim,ds4424", .data = &ds4424_info },
	{ }
};

MODULE_DEVICE_TABLE(of, ds4424_of_match);

static struct i2c_driver ds4424_driver = {
	.driver = {
		.name	= "ds4424",
		.of_match_table = ds4424_of_match,
		.pm     = pm_sleep_ptr(&ds4424_pm_ops),
	},
	.probe		= ds4424_probe,
	.remove		= ds4424_remove,
	.id_table	= ds4424_id,
};
module_i2c_driver(ds4424_driver);

MODULE_DESCRIPTION("Maxim DS4424 DAC Driver");
MODULE_AUTHOR("Ismail H. Kose <ismail.kose@maximintegrated.com>");
MODULE_AUTHOR("Vishal Sood <vishal.sood@maximintegrated.com>");
MODULE_AUTHOR("David Jung <david.jung@maximintegrated.com>");
MODULE_LICENSE("GPL v2");