Commit 1ef28bcc authored by Krzysztof Kozlowski's avatar Krzysztof Kozlowski Committed by Jonathan Cameron
Browse files

iio: adc: exynos_adc: Drop touchscreen support 



With last user of touchscreen via ADC (S3C24xx SoC) gone, drop the
remaining code from Samsung SoC ADC driver.

Reviewed-by: default avatarAndy Shevchenko <andy@kernel.org>
Signed-off-by: default avatarKrzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
Link: https://patch.msgid.link/20250830-s3c-cleanup-adc-v2-2-4f8299343d32@linaro.org


Signed-off-by: default avatarJonathan Cameron <Jonathan.Cameron@huawei.com>
parent 117b6c08

drivers/iio/adc/exynos_adc.c

+1 −195
Original line number Diff line number Diff line
@@ -19,11 +19,9 @@ 
#include <linux/clk.h>

#include <linux/completion.h>

#include <linux/of.h>

#include <linux/of_irq.h>

#include <linux/regulator/consumer.h>

#include <linux/of_platform.h>

#include <linux/err.h>

#include <linux/input.h>



#include <linux/iio/iio.h>

#include <linux/iio/machine.h>
@@ -35,14 +33,12 @@ 


/* S3C/EXYNOS4412/5250 ADC_V1 registers definitions */

#define ADC_V1_CON(x)		((x) + 0x00)

#define ADC_V1_TSC(x)		((x) + 0x04)

#define ADC_V1_DLY(x)		((x) + 0x08)

#define ADC_V1_DATX(x)		((x) + 0x0C)

#define ADC_V1_DATY(x)		((x) + 0x10)

#define ADC_V1_UPDN(x)		((x) + 0x14)

#define ADC_V1_INTCLR(x)	((x) + 0x18)

#define ADC_V1_MUX(x)		((x) + 0x1c)

#define ADC_V1_CLRINTPNDNUP(x)	((x) + 0x20)



/* Future ADC_V2 registers definitions */

#define ADC_V2_CON1(x)		((x) + 0x00)
@@ -61,17 +57,12 @@ 
/* Bit definitions for S3C2410 / S3C6410 ADC */

#define ADC_S3C2410_CON_SELMUX(x) (((x) & 7) << 3)



/* touch screen always uses channel 0 */

#define ADC_S3C2410_MUX_TS	0



/* ADCTSC Register Bits */

#define ADC_S3C2443_TSC_UD_SEN		(1u << 8)

#define ADC_S3C2410_TSC_YM_SEN		(1u << 7)

#define ADC_S3C2410_TSC_YP_SEN		(1u << 6)

#define ADC_S3C2410_TSC_XM_SEN		(1u << 5)

#define ADC_S3C2410_TSC_XP_SEN		(1u << 4)

#define ADC_S3C2410_TSC_PULL_UP_DISABLE	(1u << 3)

#define ADC_S3C2410_TSC_AUTO_PST	(1u << 2)

#define ADC_S3C2410_TSC_XY_PST(x)	(((x) & 0x3) << 0)



#define ADC_TSC_WAIT4INT (ADC_S3C2410_TSC_YM_SEN | \
@@ -79,12 +70,6 @@ 
			 ADC_S3C2410_TSC_XP_SEN | \

			 ADC_S3C2410_TSC_XY_PST(3))



#define ADC_TSC_AUTOPST	(ADC_S3C2410_TSC_YM_SEN | \

			 ADC_S3C2410_TSC_YP_SEN | \

			 ADC_S3C2410_TSC_XP_SEN | \

			 ADC_S3C2410_TSC_AUTO_PST | \

			 ADC_S3C2410_TSC_XY_PST(0))



/* Bit definitions for ADC_V2 */

#define ADC_V2_CON1_SOFT_RESET	(1u << 2)
@@ -116,13 +101,11 @@ 
struct exynos_adc {

	struct exynos_adc_data	*data;

	struct device		*dev;

	struct input_dev	*input;

	void __iomem		*regs;

	struct regmap		*pmu_map;

	struct clk		*clk;

	struct clk		*sclk;

	unsigned int		irq;

	unsigned int		tsirq;

	unsigned int		delay;

	struct regulator	*vdd;
@@ -131,12 +114,6 @@ struct exynos_adc { 
	u32			value;

	unsigned int            version;



	bool			ts_enabled;



	bool			read_ts;

	u32			ts_x;

	u32			ts_y;



	/*

	 * Lock to protect from potential concurrent access to the

	 * completion callback during a manual conversion. For this driver
@@ -507,55 +484,13 @@ static int exynos_read_raw(struct iio_dev *indio_dev, 
	return ret;

}



static int exynos_read_s3c64xx_ts(struct iio_dev *indio_dev, int *x, int *y)

{

	struct exynos_adc *info = iio_priv(indio_dev);

	unsigned long time_left;

	int ret;



	mutex_lock(&info->lock);

	info->read_ts = true;



	reinit_completion(&info->completion);



	writel(ADC_S3C2410_TSC_PULL_UP_DISABLE | ADC_TSC_AUTOPST,

	       ADC_V1_TSC(info->regs));



	/* Select the ts channel to be used and Trigger conversion */

	info->data->start_conv(info, ADC_S3C2410_MUX_TS);



	time_left = wait_for_completion_timeout(&info->completion,

						EXYNOS_ADC_TIMEOUT);

	if (time_left == 0) {

		dev_warn(&indio_dev->dev, "Conversion timed out! Resetting\n");

		if (info->data->init_hw)

			info->data->init_hw(info);

		ret = -ETIMEDOUT;

	} else {

		*x = info->ts_x;

		*y = info->ts_y;

		ret = 0;

	}



	info->read_ts = false;

	mutex_unlock(&info->lock);



	return ret;

}



static irqreturn_t exynos_adc_isr(int irq, void *dev_id)

{

	struct exynos_adc *info = dev_id;

	u32 mask = info->data->mask;



	/* Read value */

	if (info->read_ts) {

		info->ts_x = readl(ADC_V1_DATX(info->regs));

		info->ts_y = readl(ADC_V1_DATY(info->regs));

		writel(ADC_TSC_WAIT4INT | ADC_S3C2443_TSC_UD_SEN, ADC_V1_TSC(info->regs));

	} else {

	info->value = readl(ADC_V1_DATX(info->regs)) & mask;

	}



	/* clear irq */

	if (info->data->clear_irq)
@@ -566,46 +501,6 @@ static irqreturn_t exynos_adc_isr(int irq, void *dev_id) 
	return IRQ_HANDLED;

}



/*

 * Here we (ab)use a threaded interrupt handler to stay running

 * for as long as the touchscreen remains pressed, we report

 * a new event with the latest data and then sleep until the

 * next timer tick. This mirrors the behavior of the old

 * driver, with much less code.

 */

static irqreturn_t exynos_ts_isr(int irq, void *dev_id)

{

	struct exynos_adc *info = dev_id;

	struct iio_dev *dev = dev_get_drvdata(info->dev);

	u32 x, y;

	bool pressed;

	int ret;



	while (READ_ONCE(info->ts_enabled)) {

		ret = exynos_read_s3c64xx_ts(dev, &x, &y);

		if (ret == -ETIMEDOUT)

			break;



		pressed = x & y & ADC_DATX_PRESSED;

		if (!pressed) {

			input_report_key(info->input, BTN_TOUCH, 0);

			input_sync(info->input);

			break;

		}



		input_report_abs(info->input, ABS_X, x & ADC_DATX_MASK);

		input_report_abs(info->input, ABS_Y, y & ADC_DATY_MASK);

		input_report_key(info->input, BTN_TOUCH, 1);

		input_sync(info->input);



		usleep_range(1000, 1100);

	}



	writel(0, ADC_V1_CLRINTPNDNUP(info->regs));



	return IRQ_HANDLED;

}



static int exynos_adc_reg_access(struct iio_dev *indio_dev,

			      unsigned reg, unsigned writeval,

			      unsigned *readval)
@@ -657,70 +552,12 @@ static int exynos_adc_remove_devices(struct device *dev, void *c) 
	return 0;

}



static int exynos_adc_ts_open(struct input_dev *dev)

{

	struct exynos_adc *info = input_get_drvdata(dev);



	WRITE_ONCE(info->ts_enabled, true);

	enable_irq(info->tsirq);



	return 0;

}



static void exynos_adc_ts_close(struct input_dev *dev)

{

	struct exynos_adc *info = input_get_drvdata(dev);



	WRITE_ONCE(info->ts_enabled, false);

	disable_irq(info->tsirq);

}



static int exynos_adc_ts_init(struct exynos_adc *info)

{

	int ret;



	if (info->tsirq <= 0)

		return -ENODEV;



	info->input = input_allocate_device();

	if (!info->input)

		return -ENOMEM;



	info->input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);

	info->input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);



	input_set_abs_params(info->input, ABS_X, 0, 0x3FF, 0, 0);

	input_set_abs_params(info->input, ABS_Y, 0, 0x3FF, 0, 0);



	info->input->name = "S3C24xx TouchScreen";

	info->input->id.bustype = BUS_HOST;

	info->input->open = exynos_adc_ts_open;

	info->input->close = exynos_adc_ts_close;



	input_set_drvdata(info->input, info);



	ret = input_register_device(info->input);

	if (ret) {

		input_free_device(info->input);

		return ret;

	}



	ret = request_threaded_irq(info->tsirq, NULL, exynos_ts_isr,

				   IRQF_ONESHOT | IRQF_NO_AUTOEN,

				   "touchscreen", info);

	if (ret)

		input_unregister_device(info->input);



	return ret;

}



static int exynos_adc_probe(struct platform_device *pdev)

{

	struct exynos_adc *info = NULL;

	struct device_node *np = pdev->dev.of_node;

	struct s3c2410_ts_mach_info *pdata = dev_get_platdata(&pdev->dev);

	struct iio_dev *indio_dev = NULL;

	bool has_ts = false;

	int ret;

	int irq;
@@ -751,27 +588,10 @@ static int exynos_adc_probe(struct platform_device *pdev) 
		}

	}



	/* leave out any TS related code if unreachable */

	if (IS_REACHABLE(CONFIG_INPUT)) {

		has_ts = of_property_read_bool(pdev->dev.of_node,

					       "has-touchscreen") || pdata;

	}



	irq = platform_get_irq(pdev, 0);

	if (irq < 0)

		return irq;

	info->irq = irq;



	if (has_ts) {

		irq = platform_get_irq(pdev, 1);

		if (irq == -EPROBE_DEFER)

			return irq;



		info->tsirq = irq;

	} else {

		info->tsirq = -1;

	}



	info->dev = &pdev->dev;



	init_completion(&info->completion);
@@ -840,11 +660,6 @@ static int exynos_adc_probe(struct platform_device *pdev) 
	else

		info->delay = 10000;



	if (has_ts)

		ret = exynos_adc_ts_init(info);

	if (ret)

		goto err_iio;



	ret = of_platform_populate(np, exynos_adc_match, NULL, &indio_dev->dev);

	if (ret < 0) {

		dev_err(&pdev->dev, "failed adding child nodes\n");
@@ -856,11 +671,6 @@ static int exynos_adc_probe(struct platform_device *pdev) 
err_of_populate:

	device_for_each_child(&indio_dev->dev, NULL,

				exynos_adc_remove_devices);

	if (has_ts) {

		input_unregister_device(info->input);

		free_irq(info->tsirq, info);

	}

err_iio:

	iio_device_unregister(indio_dev);

err_irq:

	free_irq(info->irq, info);
@@ -880,10 +690,6 @@ static void exynos_adc_remove(struct platform_device *pdev) 
	struct iio_dev *indio_dev = platform_get_drvdata(pdev);

	struct exynos_adc *info = iio_priv(indio_dev);



	if (IS_REACHABLE(CONFIG_INPUT) && info->input) {

		free_irq(info->tsirq, info);

		input_unregister_device(info->input);

	}

	device_for_each_child(&indio_dev->dev, NULL,

				exynos_adc_remove_devices);

	iio_device_unregister(indio_dev);