hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

iio: adc: qcom-pm8xxx-xoadc: convert to device properties 

Make the conversion to firmware agnostic device properties. As part of
the conversion the IIO inkern interface 'of_xlate()' is also converted to
'fwnode_xlate()'. The goal is to completely drop 'of_xlate' and hence OF
dependencies from IIO.

Signed-off-by: Nuno Sá <nuno.sa@analog.com>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com>
Link: https://lore.kernel.org/r/20220715122903.332535-11-nuno.sa@analog.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
This commit is contained in:
Nuno Sá 2022-07-15 14:28:58 +02:00 committed by Jonathan Cameron
parent 34b6eb8935
commit 9e90c1772f
1 changed files with 28 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
drivers/iio/adc/qcom-pm8xxx-xoadc.c
View File

@ -14,9 +14,9 @@
#include <linux/iio/iio.h> #include <linux/iio/iio.h>
#include <linux/iio/sysfs.h> #include <linux/iio/sysfs.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/of.h> #include <linux/mod_devicetable.h>
#include <linux/of_device.h>
#include <linux/platform_device.h> #include <linux/platform_device.h>
#include <linux/property.h>
#include <linux/regmap.h> #include <linux/regmap.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
@ -694,8 +694,8 @@ static int pm8xxx_read_raw(struct iio_dev *indio_dev,
} }
} }
static int pm8xxx_of_xlate(struct iio_dev *indio_dev, static int pm8xxx_fwnode_xlate(struct iio_dev *indio_dev,
const struct of_phandle_args *iiospec) const struct fwnode_reference_args *iiospec)
{ {
struct pm8xxx_xoadc *adc = iio_priv(indio_dev); struct pm8xxx_xoadc *adc = iio_priv(indio_dev);
u8 pre_scale_mux; u8 pre_scale_mux;
@ -706,10 +706,10 @@ static int pm8xxx_of_xlate(struct iio_dev *indio_dev,
* First cell is prescaler or premux, second cell is analog * First cell is prescaler or premux, second cell is analog
* mux. * mux.
*/ */
if (iiospec->args_count != 2) { if (iiospec->nargs != 2) {
dev_err(&indio_dev->dev, "wrong number of arguments for %pOFn need 2 got %d\n", dev_err(&indio_dev->dev, "wrong number of arguments for %pfwP need 2 got %d\n",
iiospec->np, iiospec->fwnode,
iiospec->args_count); iiospec->nargs);
return -EINVAL; return -EINVAL;
} }
pre_scale_mux = (u8)iiospec->args[0]; pre_scale_mux = (u8)iiospec->args[0];
@ -727,34 +727,34 @@ static int pm8xxx_of_xlate(struct iio_dev *indio_dev,
} }
static const struct iio_info pm8xxx_xoadc_info = { static const struct iio_info pm8xxx_xoadc_info = {
.of_xlate = pm8xxx_of_xlate, .fwnode_xlate = pm8xxx_fwnode_xlate,
.read_raw = pm8xxx_read_raw, .read_raw = pm8xxx_read_raw,
}; };
static int pm8xxx_xoadc_parse_channel(struct device *dev, static int pm8xxx_xoadc_parse_channel(struct device *dev,
struct device_node *np, struct fwnode_handle *fwnode,
const struct xoadc_channel *hw_channels, const struct xoadc_channel *hw_channels,
struct iio_chan_spec *iio_chan, struct iio_chan_spec *iio_chan,
struct pm8xxx_chan_info *ch) struct pm8xxx_chan_info *ch)
{ {
const char *name = np->name; const char *name = fwnode_get_name(fwnode);
const struct xoadc_channel *hwchan; const struct xoadc_channel *hwchan;
u32 pre_scale_mux, amux_channel; u32 pre_scale_mux, amux_channel, reg[2];
u32 rsv, dec; u32 rsv, dec;
int ret; int ret;
int chid; int chid;
ret = of_property_read_u32_index(np, "reg", 0, &pre_scale_mux); ret = fwnode_property_read_u32_array(fwnode, "reg", reg,
ARRAY_SIZE(reg));
if (ret) { if (ret) {
dev_err(dev, "invalid pre scale/mux number %s\n", name); dev_err(dev, "invalid pre scale/mux or amux channel number %s\n",
return ret; name);
}
ret = of_property_read_u32_index(np, "reg", 1, &amux_channel);
if (ret) {
dev_err(dev, "invalid amux channel number %s\n", name);
return ret; return ret;
} }
pre_scale_mux = reg[0];
amux_channel = reg[1];
/* Find the right channel setting */ /* Find the right channel setting */
chid = 0; chid = 0;
hwchan = &hw_channels[0]; hwchan = &hw_channels[0];
@ -778,7 +778,7 @@ static int pm8xxx_xoadc_parse_channel(struct device *dev,
/* Everyone seems to use default ("type 2") decimation */ /* Everyone seems to use default ("type 2") decimation */
ch->decimation = VADC_DEF_DECIMATION; ch->decimation = VADC_DEF_DECIMATION;
if (!of_property_read_u32(np, "qcom,ratiometric", &rsv)) { if (!fwnode_property_read_u32(fwnode, "qcom,ratiometric", &rsv)) {
ch->calibration = VADC_CALIB_RATIOMETRIC; ch->calibration = VADC_CALIB_RATIOMETRIC;
if (rsv > XOADC_RSV_MAX) { if (rsv > XOADC_RSV_MAX) {
dev_err(dev, "%s too large RSV value %d\n", name, rsv); dev_err(dev, "%s too large RSV value %d\n", name, rsv);
@ -791,7 +791,7 @@ static int pm8xxx_xoadc_parse_channel(struct device *dev,
} }
/* Optional decimation, if omitted we use the default */ /* Optional decimation, if omitted we use the default */
ret = of_property_read_u32(np, "qcom,decimation", &dec); ret = fwnode_property_read_u32(fwnode, "qcom,decimation", &dec);
if (!ret) { if (!ret) {
ret = qcom_vadc_decimation_from_dt(dec); ret = qcom_vadc_decimation_from_dt(dec);
if (ret < 0) { if (ret < 0) {
@ -820,15 +820,14 @@ static int pm8xxx_xoadc_parse_channel(struct device *dev,
return 0; return 0;
} }
static int pm8xxx_xoadc_parse_channels(struct pm8xxx_xoadc *adc, static int pm8xxx_xoadc_parse_channels(struct pm8xxx_xoadc *adc)
struct device_node *np)
{ {
struct device_node *child; struct fwnode_handle *child;
struct pm8xxx_chan_info *ch; struct pm8xxx_chan_info *ch;
int ret; int ret;
int i; int i;
adc->nchans = of_get_available_child_count(np); adc->nchans = device_get_child_node_count(adc->dev);
if (!adc->nchans) { if (!adc->nchans) {
dev_err(adc->dev, "no channel children\n"); dev_err(adc->dev, "no channel children\n");
return -ENODEV; return -ENODEV;
@ -846,14 +845,14 @@ static int pm8xxx_xoadc_parse_channels(struct pm8xxx_xoadc *adc,
return -ENOMEM; return -ENOMEM;
i = 0; i = 0;
for_each_available_child_of_node(np, child) { device_for_each_child_node(adc->dev, child) {
ch = &adc->chans[i]; ch = &adc->chans[i];
ret = pm8xxx_xoadc_parse_channel(adc->dev, child, ret = pm8xxx_xoadc_parse_channel(adc->dev, child,
adc->variant->channels, adc->variant->channels,
&adc->iio_chans[i], &adc->iio_chans[i],
ch); ch);
if (ret) { if (ret) {
of_node_put(child); fwnode_handle_put(child);
return ret; return ret;
} }
i++; i++;
@ -884,12 +883,11 @@ static int pm8xxx_xoadc_probe(struct platform_device *pdev)
const struct xoadc_variant *variant; const struct xoadc_variant *variant;
struct pm8xxx_xoadc *adc; struct pm8xxx_xoadc *adc;
struct iio_dev *indio_dev; struct iio_dev *indio_dev;
struct device_node *np = pdev->dev.of_node;
struct regmap *map; struct regmap *map;
struct device *dev = &pdev->dev; struct device *dev = &pdev->dev;
int ret; int ret;
variant = of_device_get_match_data(dev); variant = device_get_match_data(dev);
if (!variant) if (!variant)
return -ENODEV; return -ENODEV;
@ -904,7 +902,7 @@ static int pm8xxx_xoadc_probe(struct platform_device *pdev)
init_completion(&adc->complete); init_completion(&adc->complete);
mutex_init(&adc->lock); mutex_init(&adc->lock);
ret = pm8xxx_xoadc_parse_channels(adc, np); ret = pm8xxx_xoadc_parse_channels(adc);
if (ret) if (ret)
return ret; return ret;