Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d5acf594 authored by Hector Palacios's avatar Hector Palacios Committed by Jonathan Cameron
Browse files

iio: mxs-lradc: add scale_available file to channels 



Adds in_voltageX_scale_available file for every channel to read
the different available scales.
There are two scales per channel:
 [0] = divider_by_two disabled (default)
 [1] = divider_by_two enabled
The scale is a struct made of integer and nano parts to build
a long decimal number.

Signed-off-by: default avatarHector Palacios <hector.palacios@digi.com>
Signed-off-by: default avatarAlexandre Belloni <alexandre.belloni@free-electrons.com>
Acked-by: default avatarMarek Vasut <marex@denx.de>
Signed-off-by: default avatarJonathan Cameron <jic23@kernel.org>
parent f6db68a4

drivers/staging/iio/adc/mxs-lradc.c

+105 −1
Original line number Diff line number Diff line
@@ -38,6 +38,7 @@ 
#include <linux/clk.h>



#include <linux/iio/iio.h>

#include <linux/iio/sysfs.h>

#include <linux/iio/buffer.h>

#include <linux/iio/trigger.h>

#include <linux/iio/trigger_consumer.h>
@@ -184,6 +185,11 @@ enum lradc_ts_plate { 
	LRADC_SAMPLE_VALID,

};



struct mxs_lradc_scale {

	unsigned int		integer;

	unsigned int		nano;

};



struct mxs_lradc {

	struct device		*dev;

	void __iomem		*base;
@@ -199,6 +205,7 @@ struct mxs_lradc { 
	struct completion	completion;



	const uint32_t		*vref_mv;

	struct mxs_lradc_scale	scale_avail[LRADC_MAX_TOTAL_CHANS][2];



	/*

	 * Touchscreen LRADC channels receives a private slot in the CTRL4
@@ -929,9 +936,84 @@ static int mxs_lradc_read_raw(struct iio_dev *iio_dev, 
	return -EINVAL;

}



static ssize_t mxs_lradc_show_scale_available_ch(struct device *dev,

		struct device_attribute *attr,

		char *buf,

		int ch)

{

	struct iio_dev *iio = dev_to_iio_dev(dev);

	struct mxs_lradc *lradc = iio_priv(iio);

	int i, len = 0;



	for (i = 0; i < ARRAY_SIZE(lradc->scale_avail[ch]); i++)

		len += sprintf(buf + len, "%d.%09u ",

			       lradc->scale_avail[ch][i].integer,

			       lradc->scale_avail[ch][i].nano);



	len += sprintf(buf + len, "\n");



	return len;

}



static ssize_t mxs_lradc_show_scale_available(struct device *dev,

		struct device_attribute *attr,

		char *buf)

{

	struct iio_dev_attr *iio_attr = to_iio_dev_attr(attr);



	return mxs_lradc_show_scale_available_ch(dev, attr, buf,

						 iio_attr->address);

}



#define SHOW_SCALE_AVAILABLE_ATTR(ch)					\

static IIO_DEVICE_ATTR(in_voltage##ch##_scale_available, S_IRUGO,	\

		       mxs_lradc_show_scale_available, NULL, ch)



SHOW_SCALE_AVAILABLE_ATTR(0);

SHOW_SCALE_AVAILABLE_ATTR(1);

SHOW_SCALE_AVAILABLE_ATTR(2);

SHOW_SCALE_AVAILABLE_ATTR(3);

SHOW_SCALE_AVAILABLE_ATTR(4);

SHOW_SCALE_AVAILABLE_ATTR(5);

SHOW_SCALE_AVAILABLE_ATTR(6);

SHOW_SCALE_AVAILABLE_ATTR(7);

SHOW_SCALE_AVAILABLE_ATTR(8);

SHOW_SCALE_AVAILABLE_ATTR(9);

SHOW_SCALE_AVAILABLE_ATTR(10);

SHOW_SCALE_AVAILABLE_ATTR(11);

SHOW_SCALE_AVAILABLE_ATTR(12);

SHOW_SCALE_AVAILABLE_ATTR(13);

SHOW_SCALE_AVAILABLE_ATTR(14);

SHOW_SCALE_AVAILABLE_ATTR(15);



static struct attribute *mxs_lradc_attributes[] = {

	&iio_dev_attr_in_voltage0_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage1_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage2_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage3_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage4_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage5_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage6_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage7_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage8_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage9_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage10_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage11_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage12_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage13_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage14_scale_available.dev_attr.attr,

	&iio_dev_attr_in_voltage15_scale_available.dev_attr.attr,

	NULL

};



static const struct attribute_group mxs_lradc_attribute_group = {

	.attrs = mxs_lradc_attributes,

};



static const struct iio_info mxs_lradc_iio_info = {

	.driver_module		= THIS_MODULE,

	.read_raw		= mxs_lradc_read_raw,

	.attrs			= &mxs_lradc_attribute_group,

};



static int mxs_lradc_ts_open(struct input_dev *dev)
@@ -1241,6 +1323,7 @@ static const struct iio_buffer_setup_ops mxs_lradc_buffer_ops = { 
	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |		\

			      BIT(IIO_CHAN_INFO_SCALE),		\

	.channel = (idx),					\

	.address = (idx),					\

	.scan_type = {						\

		.sign = 'u',					\

		.realbits = LRADC_RESOLUTION,			\
@@ -1386,7 +1469,8 @@ static int mxs_lradc_probe(struct platform_device *pdev) 
	struct iio_dev *iio;

	struct resource *iores;

	int ret = 0, touch_ret;

	int i;

	int i, s;

	unsigned int scale_uv;



	/* Allocate the IIO device. */

	iio = devm_iio_device_alloc(dev, sizeof(*lradc));
@@ -1456,6 +1540,26 @@ static int mxs_lradc_probe(struct platform_device *pdev) 
	if (ret)

		goto err_trig;



	/* Populate available ADC input ranges */

	for (i = 0; i < LRADC_MAX_TOTAL_CHANS; i++) {

		for (s = 0; s < ARRAY_SIZE(lradc->scale_avail[i]); s++) {

			/*

			 * [s=0] = optional divider by two disabled (default)

			 * [s=1] = optional divider by two enabled

			 *

			 * The scale is calculated by doing:

			 *   Vref >> (realbits - s)

			 * which multiplies by two on the second component

			 * of the array.

			 */

			scale_uv = ((u64)lradc->vref_mv[i] * 100000000) >>

				   (iio->channels[i].scan_type.realbits - s);

			lradc->scale_avail[i][s].nano =

					do_div(scale_uv, 100000000) * 10;

			lradc->scale_avail[i][s].integer = scale_uv;

		}

	}



	/* Configure the hardware. */

	ret = mxs_lradc_hw_init(lradc);

	if (ret)