mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-21 08:19:28 +00:00
![Alexandru Ardelean](/assets/img/avatar_default.png)
This patch applies the semantic patch: @@ expression I, P, SP; @@ I = devm_iio_device_alloc(P, SP); ... - I->dev.parent = P; It updates 302 files and does 307 deletions. This semantic patch also removes some comments like '/* Establish that the iio_dev is a child of the i2c device */' But this is is only done in case where the block is left empty. The patch does not seem to cover all cases. It looks like in some cases a different variable is used in some cases to assign the parent, but it points to the same reference. In other cases, the block covered by ... may be just too big to be covered by the semantic patch. However, this looks pretty good as well, as it does cover a big bulk of the drivers that should remove the parent assignment. Signed-off-by: Alexandru Ardelean <alexandru.ardelean@analog.com> Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
229 lines
5.3 KiB
C
229 lines
5.3 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* IIO DAC driver for Analog Devices AD8801 DAC
|
|
*
|
|
* Copyright (C) 2016 Gwenhael Goavec-Merou
|
|
*/
|
|
|
|
#include <linux/iio/iio.h>
|
|
#include <linux/module.h>
|
|
#include <linux/regulator/consumer.h>
|
|
#include <linux/spi/spi.h>
|
|
#include <linux/sysfs.h>
|
|
|
|
#define AD8801_CFG_ADDR_OFFSET 8
|
|
|
|
enum ad8801_device_ids {
|
|
ID_AD8801,
|
|
ID_AD8803,
|
|
};
|
|
|
|
struct ad8801_state {
|
|
struct spi_device *spi;
|
|
unsigned char dac_cache[8]; /* Value write on each channel */
|
|
unsigned int vrefh_mv;
|
|
unsigned int vrefl_mv;
|
|
struct regulator *vrefh_reg;
|
|
struct regulator *vrefl_reg;
|
|
|
|
__be16 data ____cacheline_aligned;
|
|
};
|
|
|
|
static int ad8801_spi_write(struct ad8801_state *state,
|
|
u8 channel, unsigned char value)
|
|
{
|
|
state->data = cpu_to_be16((channel << AD8801_CFG_ADDR_OFFSET) | value);
|
|
return spi_write(state->spi, &state->data, sizeof(state->data));
|
|
}
|
|
|
|
static int ad8801_write_raw(struct iio_dev *indio_dev,
|
|
struct iio_chan_spec const *chan, int val, int val2, long mask)
|
|
{
|
|
struct ad8801_state *state = iio_priv(indio_dev);
|
|
int ret;
|
|
|
|
switch (mask) {
|
|
case IIO_CHAN_INFO_RAW:
|
|
if (val >= 256 || val < 0)
|
|
return -EINVAL;
|
|
|
|
ret = ad8801_spi_write(state, chan->channel, val);
|
|
if (ret == 0)
|
|
state->dac_cache[chan->channel] = val;
|
|
break;
|
|
default:
|
|
ret = -EINVAL;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ad8801_read_raw(struct iio_dev *indio_dev,
|
|
struct iio_chan_spec const *chan, int *val, int *val2, long info)
|
|
{
|
|
struct ad8801_state *state = iio_priv(indio_dev);
|
|
|
|
switch (info) {
|
|
case IIO_CHAN_INFO_RAW:
|
|
*val = state->dac_cache[chan->channel];
|
|
return IIO_VAL_INT;
|
|
case IIO_CHAN_INFO_SCALE:
|
|
*val = state->vrefh_mv - state->vrefl_mv;
|
|
*val2 = 8;
|
|
return IIO_VAL_FRACTIONAL_LOG2;
|
|
case IIO_CHAN_INFO_OFFSET:
|
|
*val = state->vrefl_mv;
|
|
return IIO_VAL_INT;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static const struct iio_info ad8801_info = {
|
|
.read_raw = ad8801_read_raw,
|
|
.write_raw = ad8801_write_raw,
|
|
};
|
|
|
|
#define AD8801_CHANNEL(chan) { \
|
|
.type = IIO_VOLTAGE, \
|
|
.indexed = 1, \
|
|
.output = 1, \
|
|
.channel = chan, \
|
|
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
|
|
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
|
|
BIT(IIO_CHAN_INFO_OFFSET), \
|
|
}
|
|
|
|
static const struct iio_chan_spec ad8801_channels[] = {
|
|
AD8801_CHANNEL(0),
|
|
AD8801_CHANNEL(1),
|
|
AD8801_CHANNEL(2),
|
|
AD8801_CHANNEL(3),
|
|
AD8801_CHANNEL(4),
|
|
AD8801_CHANNEL(5),
|
|
AD8801_CHANNEL(6),
|
|
AD8801_CHANNEL(7),
|
|
};
|
|
|
|
static int ad8801_probe(struct spi_device *spi)
|
|
{
|
|
struct iio_dev *indio_dev;
|
|
struct ad8801_state *state;
|
|
const struct spi_device_id *id;
|
|
int ret;
|
|
|
|
indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*state));
|
|
if (indio_dev == NULL)
|
|
return -ENOMEM;
|
|
|
|
state = iio_priv(indio_dev);
|
|
state->spi = spi;
|
|
id = spi_get_device_id(spi);
|
|
|
|
state->vrefh_reg = devm_regulator_get(&spi->dev, "vrefh");
|
|
if (IS_ERR(state->vrefh_reg)) {
|
|
dev_err(&spi->dev, "Vrefh regulator not specified\n");
|
|
return PTR_ERR(state->vrefh_reg);
|
|
}
|
|
|
|
ret = regulator_enable(state->vrefh_reg);
|
|
if (ret) {
|
|
dev_err(&spi->dev, "Failed to enable vrefh regulator: %d\n",
|
|
ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = regulator_get_voltage(state->vrefh_reg);
|
|
if (ret < 0) {
|
|
dev_err(&spi->dev, "Failed to read vrefh regulator: %d\n",
|
|
ret);
|
|
goto error_disable_vrefh_reg;
|
|
}
|
|
state->vrefh_mv = ret / 1000;
|
|
|
|
if (id->driver_data == ID_AD8803) {
|
|
state->vrefl_reg = devm_regulator_get(&spi->dev, "vrefl");
|
|
if (IS_ERR(state->vrefl_reg)) {
|
|
dev_err(&spi->dev, "Vrefl regulator not specified\n");
|
|
ret = PTR_ERR(state->vrefl_reg);
|
|
goto error_disable_vrefh_reg;
|
|
}
|
|
|
|
ret = regulator_enable(state->vrefl_reg);
|
|
if (ret) {
|
|
dev_err(&spi->dev, "Failed to enable vrefl regulator: %d\n",
|
|
ret);
|
|
goto error_disable_vrefh_reg;
|
|
}
|
|
|
|
ret = regulator_get_voltage(state->vrefl_reg);
|
|
if (ret < 0) {
|
|
dev_err(&spi->dev, "Failed to read vrefl regulator: %d\n",
|
|
ret);
|
|
goto error_disable_vrefl_reg;
|
|
}
|
|
state->vrefl_mv = ret / 1000;
|
|
} else {
|
|
state->vrefl_mv = 0;
|
|
state->vrefl_reg = NULL;
|
|
}
|
|
|
|
spi_set_drvdata(spi, indio_dev);
|
|
indio_dev->info = &ad8801_info;
|
|
indio_dev->modes = INDIO_DIRECT_MODE;
|
|
indio_dev->channels = ad8801_channels;
|
|
indio_dev->num_channels = ARRAY_SIZE(ad8801_channels);
|
|
indio_dev->name = id->name;
|
|
|
|
ret = iio_device_register(indio_dev);
|
|
if (ret) {
|
|
dev_err(&spi->dev, "Failed to register iio device: %d\n",
|
|
ret);
|
|
goto error_disable_vrefl_reg;
|
|
}
|
|
|
|
return 0;
|
|
|
|
error_disable_vrefl_reg:
|
|
if (state->vrefl_reg)
|
|
regulator_disable(state->vrefl_reg);
|
|
error_disable_vrefh_reg:
|
|
regulator_disable(state->vrefh_reg);
|
|
return ret;
|
|
}
|
|
|
|
static int ad8801_remove(struct spi_device *spi)
|
|
{
|
|
struct iio_dev *indio_dev = spi_get_drvdata(spi);
|
|
struct ad8801_state *state = iio_priv(indio_dev);
|
|
|
|
iio_device_unregister(indio_dev);
|
|
if (state->vrefl_reg)
|
|
regulator_disable(state->vrefl_reg);
|
|
regulator_disable(state->vrefh_reg);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct spi_device_id ad8801_ids[] = {
|
|
{"ad8801", ID_AD8801},
|
|
{"ad8803", ID_AD8803},
|
|
{}
|
|
};
|
|
MODULE_DEVICE_TABLE(spi, ad8801_ids);
|
|
|
|
static struct spi_driver ad8801_driver = {
|
|
.driver = {
|
|
.name = "ad8801",
|
|
},
|
|
.probe = ad8801_probe,
|
|
.remove = ad8801_remove,
|
|
.id_table = ad8801_ids,
|
|
};
|
|
module_spi_driver(ad8801_driver);
|
|
|
|
MODULE_AUTHOR("Gwenhael Goavec-Merou <gwenhael.goavec-merou@trabucayre.com>");
|
|
MODULE_DESCRIPTION("Analog Devices AD8801/AD8803 DAC");
|
|
MODULE_LICENSE("GPL v2");
|