// SPDX-License-Identifier: GPL-2.0
|
/*
|
* Copyright (c) 2018 Rockchip Electronics Co. Ltd.
|
*
|
* Author: Ziyuan Xu <xzy.xu@rock-chips.com>
|
*/
|
|
#include <linux/module.h>
|
#include <linux/gpio/consumer.h>
|
#include <linux/platform_device.h>
|
#include <linux/of.h>
|
#include <linux/of_device.h>
|
#include <linux/iio/consumer.h>
|
#include <linux/iio/iio.h>
|
|
/**
|
* id: the index of analog switch inputs
|
* saradc_chan_id: the index of analog switch 'x' output
|
* gpio_mask: set the value of switch-gpios with mask, that
|
* makes the 'id' connect to 'saradc_chan_id'.
|
*/
|
struct gpio_muxadc_chan_data {
|
u32 id;
|
u32 saradc_chan_id;
|
u32 gpio_mask;
|
};
|
|
#define MUXADC_CHANNEL(_index, _id, _mask) { \
|
.id = _index, \
|
.saradc_chan_id = _id, \
|
.gpio_mask = _mask, \
|
}
|
|
/**
|
* nr_chans: the number of analog switch 'x' output
|
* saradc_nr_chans: the number of analog switch inputs
|
* chans: pointer to get the muxadc channel information
|
*/
|
struct gpio_muxadc_data {
|
u32 nr_chans;
|
u32 saradc_nr_chans;
|
const struct gpio_muxadc_chan_data *chans;
|
};
|
|
/**
|
* gpios: pointer of digital enable input gpios
|
* adc_chans: pointer of the 'saraadc' channel
|
* muxchans: specification of a single analog switch 'x'
|
* output channel
|
* data: pointer to get the muxadc channels information
|
* nr_chans: the number of analog switch 'x' output
|
*/
|
struct gpio_muxadc {
|
struct gpio_descs *gpios;
|
struct iio_channel *adc_chans;
|
struct iio_chan_spec *muxchans;
|
const struct gpio_muxadc_data *data;
|
u32 nr_chans;
|
};
|
|
static int gpio_muxadc_chan_read_by_index(struct gpio_muxadc *muxadc,
|
int index, int *val)
|
{
|
struct iio_channel *saradc_chan;
|
const struct gpio_muxadc_chan_data *chan_data;
|
u32 i, saradc_chan_id;
|
|
chan_data = &muxadc->data->chans[index];
|
for (i = 0; i < muxadc->gpios->ndescs; i++) {
|
struct gpio_desc *gpiod = muxadc->gpios->desc[i];
|
int gpio_val = chan_data->gpio_mask & BIT(i) ? 1 : 0;
|
|
gpiod_set_value(gpiod, gpio_val);
|
}
|
|
saradc_chan_id = chan_data->saradc_chan_id;
|
saradc_chan = &muxadc->adc_chans[saradc_chan_id];
|
return iio_read_channel_raw(saradc_chan, val);
|
}
|
|
static int gpio_muxadc_read_raw(struct iio_dev *indio_dev,
|
struct iio_chan_spec const *chan,
|
int *val, int *val2, long mask)
|
{
|
struct gpio_muxadc *muxadc = iio_priv(indio_dev);
|
int ret = IIO_VAL_INT;
|
|
switch (mask) {
|
case IIO_CHAN_INFO_RAW:
|
ret = gpio_muxadc_chan_read_by_index(muxadc,
|
chan->channel, val);
|
break;
|
default:
|
return -EINVAL;
|
}
|
|
return ret;
|
}
|
|
static const struct iio_info gpio_muxadc_iio_info = {
|
.read_raw = gpio_muxadc_read_raw,
|
};
|
|
static const struct gpio_muxadc_chan_data mux_sgm3699_chans_data[] = {
|
MUXADC_CHANNEL(0, 0, 0b00),
|
MUXADC_CHANNEL(1, 1, 0b00),
|
MUXADC_CHANNEL(2, 2, 0b00),
|
MUXADC_CHANNEL(3, 3, 0b00),
|
MUXADC_CHANNEL(4, 0, 0b01),
|
MUXADC_CHANNEL(5, 1, 0b01),
|
MUXADC_CHANNEL(6, 2, 0b11),
|
MUXADC_CHANNEL(7, 3, 0b11),
|
};
|
|
static const struct gpio_muxadc_data mux_sgm3699_data = {
|
.saradc_nr_chans = 4,
|
.nr_chans = ARRAY_SIZE(mux_sgm3699_chans_data),
|
.chans = mux_sgm3699_chans_data,
|
};
|
|
static const struct gpio_muxadc_chan_data mux_sgm48752_chans_data[] = {
|
MUXADC_CHANNEL(0, 0, 0b00),
|
MUXADC_CHANNEL(1, 1, 0b00),
|
MUXADC_CHANNEL(2, 0, 0b10),
|
MUXADC_CHANNEL(3, 1, 0b10),
|
MUXADC_CHANNEL(4, 0, 0b01),
|
MUXADC_CHANNEL(5, 1, 0b01),
|
MUXADC_CHANNEL(6, 0, 0b11),
|
MUXADC_CHANNEL(7, 1, 0b11),
|
};
|
|
static const struct gpio_muxadc_data mux_sgm48752_data = {
|
.saradc_nr_chans = 2,
|
.nr_chans = ARRAY_SIZE(mux_sgm48752_chans_data),
|
.chans = mux_sgm48752_chans_data,
|
};
|
|
static const struct of_device_id of_gpio_muxadc_match[] = {
|
{
|
.compatible = "sgm3699",
|
.data = &mux_sgm3699_data,
|
},
|
{
|
.compatible = "sgm48752",
|
.data = &mux_sgm48752_data,
|
},
|
{},
|
};
|
MODULE_DEVICE_TABLE(of, of_gpio_muxadc_match);
|
|
static int gpio_muxadc_probe(struct platform_device *pdev)
|
{
|
struct gpio_muxadc *muxadc;
|
struct iio_dev *indio_dev;
|
const struct of_device_id *match;
|
struct device *dev = &pdev->dev;
|
struct device_node *np = pdev->dev.of_node;
|
u32 i, nr_adc_chans = 0;
|
|
indio_dev = devm_iio_device_alloc(dev, sizeof(*muxadc));
|
if (!indio_dev)
|
return -ENOMEM;
|
|
muxadc = iio_priv(indio_dev);
|
|
match = of_match_device(of_gpio_muxadc_match, dev);
|
if (!match) {
|
dev_err(dev, "failed to match device\n");
|
return -ENODEV;
|
}
|
muxadc->data = match->data;
|
|
muxadc->gpios = devm_gpiod_get_array(dev, "switch", GPIOD_OUT_LOW);
|
if (IS_ERR(muxadc->gpios)) {
|
dev_err(dev, "property of switch-gpios not specified\n");
|
return PTR_ERR(muxadc->gpios);
|
}
|
|
muxadc->adc_chans = iio_channel_get_all(dev);
|
if (IS_ERR(muxadc->adc_chans))
|
return PTR_ERR(muxadc->adc_chans);
|
/*
|
* It's necessary to get the number of input ADC, and make a
|
* comparison with chan_data->saradc_nr_chans. Otherwise it
|
* might fall in to trap.
|
*/
|
while (muxadc->adc_chans[nr_adc_chans].indio_dev)
|
nr_adc_chans++;
|
if (muxadc->data->saradc_nr_chans != nr_adc_chans) {
|
dev_err(dev, "the number of io-channels is mismatch\n");
|
return -EINVAL;
|
}
|
|
muxadc->nr_chans = of_property_count_strings(np, "labels");
|
if (muxadc->nr_chans != muxadc->data->nr_chans) {
|
dev_err(dev, "should provide %d label\n",
|
muxadc->nr_chans);
|
return -EINVAL;
|
}
|
|
muxadc->muxchans = devm_kcalloc(dev, muxadc->nr_chans,
|
sizeof(struct iio_chan_spec),
|
GFP_KERNEL);
|
if (!muxadc->muxchans)
|
return -ENOMEM;
|
|
for (i = 0; i < muxadc->nr_chans; i++) {
|
/*
|
* The specification of each muxadc channel will be
|
* in_voltage_<label> without been indexed.
|
*/
|
muxadc->muxchans[i].type = IIO_VOLTAGE;
|
muxadc->muxchans[i].channel = i;
|
muxadc->muxchans[i].info_mask_separate = BIT(IIO_CHAN_INFO_RAW);
|
of_property_read_string_index(np, "labels", i,
|
&muxadc->muxchans[i].extend_name);
|
}
|
|
indio_dev->name = dev_name(dev);
|
indio_dev->dev.parent = dev;
|
indio_dev->dev.of_node = dev->of_node;
|
indio_dev->info = &gpio_muxadc_iio_info;
|
indio_dev->modes = INDIO_DIRECT_MODE;
|
indio_dev->channels = muxadc->muxchans;
|
indio_dev->num_channels = muxadc->nr_chans;
|
|
return iio_device_register(indio_dev);
|
}
|
|
static int gpio_muxadc_remove(struct platform_device *pdev)
|
{
|
struct iio_dev *indio_dev = platform_get_drvdata(pdev);
|
|
iio_device_unregister(indio_dev);
|
return 0;
|
}
|
|
static struct platform_driver gpio_muxadc_driver = {
|
.probe = gpio_muxadc_probe,
|
.remove = gpio_muxadc_remove,
|
.driver = {
|
.name = "gpio-muxadc",
|
.of_match_table = of_gpio_muxadc_match,
|
},
|
};
|
|
module_platform_driver(gpio_muxadc_driver);
|
|
MODULE_AUTHOR("Ziyuan Xu <xzy.xu@rock-chips.com>");
|
MODULE_DESCRIPTION("GPIO MUX ADC driver");
|
MODULE_LICENSE("GPL v2");
|
