marvell/linux/drivers/input/touchscreen/asr_tsc.c - T108 - Gitiles

 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
  * ASR built-in touchscreen driver
  *
  * Copyright (C) 2023 ASR
  */

 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/clk.h>
 #include <linux/io.h>
 #include <linux/slab.h>
 #include <linux/of.h>
 #include <linux/timer.h>

 /*
  * Touchscreen controller register offsets
  */
 #define ASR_TSCR		0x0
 #define ASR_TSSR		0x4
 #define ASR_XYDR(x)	(0x8 + (x) * 0x4)

 #define ASR_TSSR_DOWN 0
 #define ASR_TSSR_UP   1

 #define ASR_TSC_MIN_XY_VAL			0
 #define ASR_TSC_MAX_XY_VAL			4095
 #define ASR_TSC_DOT_CNT_MAX			8

 #define MOD_NAME "ts-asr"

 #define tsc_readl(dev, reg) \
 	__raw_readl((dev)->tsc_base + (reg))
 #define tsc_writel(dev, reg, val) \
 	__raw_writel((val), (dev)->tsc_base + (reg))

 struct asr_tp_info {
 	int x;
 	int y;
 	int last_x;
 	int last_y;
 };

 struct asr_tsc {
 	struct timer_list move_timer;
 	struct input_dev *dev;
 	void __iomem *tsc_base;
 	int rdy_irq;
 	int up_irq;
 	int down_irq;
 	struct clk *clk;
 	struct asr_tp_info tp;
 	int dummpy_points;
 };

 #define ASR_TSC_MOVE_TIMEOUT	10	/* ms */
 #define ASR_TSC_DUMMY_POINTS	10
 #define ASR_TSC_TP_MARGIN			10

 enum {
 	TSC_MODE_IDLE = 0,
 	TSC_MODE_WAIT_PRESSDOWN,
 	TSC_MODE_WAIT_RISEUP,
 	TSC_MODE_WAIT_AUTOMEASURE,
 };
 static void asr_ts_set_mode(struct asr_tsc *tsc, int mode);

 static void asr_ts_movement_detect(struct timer_list *t)
 {
 	struct asr_tsc *tsc = from_timer(tsc, t, move_timer);
 	u32 val;
 	val = tsc_readl(tsc, ASR_TSSR);
 	if (val & ASR_TSSR_UP) {
 		asr_ts_set_mode(tsc, TSC_MODE_WAIT_PRESSDOWN);
 		return;
 	}

 	asr_ts_set_mode(tsc, TSC_MODE_WAIT_AUTOMEASURE);
 }

 static void asr_ts_adc_init(void)
 {
 	void __iomem* apb_spare;
 	u32 val;

 	apb_spare = ioremap(0xD4090000, SZ_4K);
 	if (!apb_spare) {
 		pr_err("%s: error to ioremap apb_spare base\n", __func__);
 		return;
 	}

 	val = readl(apb_spare + 0x12c);
 	val |= (1 << 8) | (1 << 20) | (1 << 22) | (0x4 << 24);
 	writel(val, apb_spare + 0x12c);
 	iounmap(apb_spare);
 }

 static void asr_ts_set_mode(struct asr_tsc *tsc, int mode)
 {
 	u32 val;
 	val = tsc_readl(tsc, ASR_TSCR);
 	val &= ~(0x3 << 1);
 	switch (mode) {
 	case TSC_MODE_WAIT_PRESSDOWN:
 		val &= ~((1 << 8) | (1 << 7));
 		val |= (1 << 6) | (1 << 9);
 		break;
 	case TSC_MODE_WAIT_RISEUP:
 		val &= ~((1 << 8) | (1 << 6));
 		val |= (1 << 7) | (1 << 9);
 		break;
 	case TSC_MODE_WAIT_AUTOMEASURE:
 		val &= ~((1 << 6) | (1 << 7) | (1 << 9));
 		val |= (1 << 8);
 		break;
 	}
 	val |= (mode << 1);
 	tsc_writel(tsc, ASR_TSCR, val);
 }

 static void asr_ts_measure(struct asr_tsc *tsc)
 {
 	int i;
 	u32 val, meas_x, meas_y, sum_x = 0, sum_y = 0;
 	u16 min_x, max_x, min_y, max_y;
 	u16 x[ASR_TSC_DOT_CNT_MAX] = {0};
 	u16 y[ASR_TSC_DOT_CNT_MAX] = {0};
 	struct asr_tp_info *tp = (struct asr_tp_info *)&tsc->tp;

 	for (i = 0; i < ASR_TSC_DOT_CNT_MAX; i++) {
 		val = tsc_readl(tsc, ASR_XYDR(i));
 		x[i] = val & 0xffff;
 		sum_x += x[i];
 		if (i == 0 ) {
 			min_x = x[0];
 			max_x = x[0];
 		}
 		if (min_x > x[i])
 			min_x = x[i];
 		if (max_x < x[i])
 			max_x = x[i];

 		y[i] = (val >> 16) & 0xffff;
 		sum_y += y[i];

 		if (i == 0 ) {
 			min_y = y[0];
 			max_y = y[0];
 		}
 		if (min_y > y[i])
 			min_y = y[i];
 		if(max_y < y[i])
 			max_y = y[i];
 		pr_debug("	%s: [%d] (%d, %d)\n", __func__, i, x[i], y[i]);
 	}

 	meas_x = (sum_x - max_x - min_x) / (ASR_TSC_DOT_CNT_MAX - 2);
 	meas_y = (sum_y - max_y - min_y) / (ASR_TSC_DOT_CNT_MAX - 2);

 	pr_debug("meas_x: %d, meas_y: %d\n", meas_x, meas_y);
 	tp->x = meas_x;
 	tp->y = meas_y;
 }

 static irqreturn_t asr_ts_down_isr(int irq, void *dev_id)
 {
 	u32 val;
 	struct asr_tsc *tsc = (struct asr_tsc *)dev_id;
 	val = tsc_readl(tsc, ASR_TSSR);

 	if (val & (1 << 6)) {
 		val |= (1 << 6);
 		tsc_writel(tsc, ASR_TSSR, val);
 		if (val & ASR_TSSR_UP) {
 			asr_ts_set_mode(tsc, TSC_MODE_WAIT_PRESSDOWN);
 			return IRQ_HANDLED;
 		}

 		tsc->dummpy_points = 1;
 		asr_ts_set_mode(tsc, TSC_MODE_WAIT_AUTOMEASURE);
 		pr_debug("%s: got down irq.\n", __func__);
 	} else {
 		pr_warn("%s: mismatch irq?\n", __func__);
 	}
 	return IRQ_HANDLED;
 }

 static irqreturn_t asr_ts_rdy_isr(int irq, void *dev_id)
 {
 	u32 val;
 	int x, y;
 	struct asr_tsc *tsc = (struct asr_tsc *)dev_id;
 	struct input_dev *input = tsc->dev;

 	val = tsc_readl(tsc, ASR_TSSR);
 	if (val & (1 << 8)) {
 		val |= (1 << 8);
 		tsc_writel(tsc, ASR_TSSR, val);
 #if 0
 		if (val & ASR_TSSR_UP) {
 			asr_ts_set_mode(tsc, TSC_MODE_WAIT_PRESSDOWN);
 			return IRQ_HANDLED;
 		}
 #endif
 		asr_ts_measure(tsc);
 		if (tsc->dummpy_points) {
 			tsc->dummpy_points++;
 			if (tsc->dummpy_points > ASR_TSC_DUMMY_POINTS) {
 				tsc->dummpy_points = 0;
 				x = tsc->tp.last_x = tsc->tp.x;
 				y = tsc->tp.last_y = tsc->tp.y;
 			} else
 				goto skip;
 		} else {
 			if (abs(tsc->tp.x - tsc->tp.last_x) < ASR_TSC_TP_MARGIN &&
 				  abs(tsc->tp.y - tsc->tp.last_y) < ASR_TSC_TP_MARGIN)
 					goto skip;
 		}

 		x = tsc->tp.last_x = tsc->tp.x;
 		y = tsc->tp.last_y = tsc->tp.y;

 		input_report_abs(input, ABS_X, x);
 		input_report_abs(input, ABS_Y, y);
 		input_report_key(input, BTN_TOUCH, 1);
 		input_sync(input);
 skip:
 		asr_ts_set_mode(tsc, TSC_MODE_WAIT_RISEUP);
 		mod_timer(&tsc->move_timer, jiffies + msecs_to_jiffies(ASR_TSC_MOVE_TIMEOUT));
 		pr_debug("%s: got rdy irq. 0x%x, (%d, %d)\n", __func__, val, tsc->tp.x, tsc->tp.y);
 	} else {
 		pr_warn("%s: mismatch irq?\n", __func__);
 	}
 	return IRQ_HANDLED;
 }

 static irqreturn_t asr_ts_up_isr(int irq, void *dev_id)
 {
 	u32 val;
 	struct asr_tsc *tsc = (struct asr_tsc *)dev_id;
 	struct input_dev *input = tsc->dev;

 	val = tsc_readl(tsc, ASR_TSSR);
 	if (val & (1 << 7)) {
 		val |= (1 << 7);
 		tsc_writel(tsc, ASR_TSSR, val);
 		if ((val & 1) == ASR_TSSR_DOWN)
 			return IRQ_HANDLED;

 		pr_debug("%s: got up irq. (%d, %d)\n", __func__, tsc->tp.x, tsc->tp.y);
 		input_report_key(input, BTN_TOUCH, 0);
 		input_sync(input);
 		asr_ts_set_mode(tsc, TSC_MODE_WAIT_PRESSDOWN);
 	} else {
 		pr_warn("%s: mismatch irq?\n", __func__);
 	}
 	return IRQ_HANDLED;
 }

 static void asr_stop_tsc(struct asr_tsc *tsc)
 {
 	tsc_writel(tsc, ASR_TSCR, 0);
 	clk_disable_unprepare(tsc->clk);
 }

 static int asr_setup_tsc(struct asr_tsc *tsc)
 {
 	u32 tmp;
 	int err;
 	asr_ts_adc_init();

 	err = clk_prepare_enable(tsc->clk);
 	if (err)
 		return err;

 	tmp = tsc_readl(tsc, ASR_TSCR);
 	tmp |= (1 << 0); 	/* enabled tsc */
 	tmp |= 0x7 << 16;	/* YD ADC channel slection */
 	tmp |= 0x6 << 11;	/* XL ADC channel slection */
 	tmp |= (1 << 8);	/* INT_RDY_EN */
 	tmp |= (0x20 << 24);
 	tmp |= (0 << 21); 	/* XL_PU_RES_SEL */
 	tmp |= ((ASR_TSC_DOT_CNT_MAX - 1) << 3); 	/* DOT_CNT */
 	tsc_writel(tsc, ASR_TSCR, tmp);
 	asr_ts_set_mode(tsc, TSC_MODE_WAIT_PRESSDOWN);
 	return 0;
 }

 static int asr_ts_open(struct input_dev *dev)
 {
 	struct asr_tsc *tsc = input_get_drvdata(dev);
 	return asr_setup_tsc(tsc);
 }

 static void asr_ts_close(struct input_dev *dev)
 {
 	struct asr_tsc *tsc = input_get_drvdata(dev);
 	asr_stop_tsc(tsc);
 }

 static int asr_ts_probe(struct platform_device *pdev)
 {
 	struct asr_tsc *tsc;
 	struct input_dev *input;
 	struct resource *res;
 	resource_size_t size;
 	int irq0, irq1, irq2;
 	int error;

 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	if (!res) {
 		dev_err(&pdev->dev, "Can't get memory resource\n");
 		return -ENOENT;
 	}

 	irq0 = platform_get_irq(pdev, 0);
 	irq1 = platform_get_irq(pdev, 1);
 	irq2 = platform_get_irq(pdev, 2);
 	if (irq0 < 0 || irq1 < 0 || irq2 < 0) {
 		dev_err(&pdev->dev, "err irq:%d, %d, %d\n", irq0, irq1, irq2);
 		return -ENOENT;
 	}

 	tsc = kzalloc(sizeof(*tsc), GFP_KERNEL);
 	input = input_allocate_device();
 	if (!tsc || !input) {
 		dev_err(&pdev->dev, "failed allocating memory\n");
 		error = -ENOMEM;
 		goto err_free_mem;
 	}

 	tsc->dev = input;
 	tsc->down_irq = irq0;
 	tsc->rdy_irq = irq1;
 	tsc->up_irq = irq2;

 	size = resource_size(res);

 	if (!request_mem_region(res->start, size, pdev->name)) {
 		dev_err(&pdev->dev, "TSC registers are not free\n");
 		error = -EBUSY;
 		goto err_free_mem;
 	}

 	tsc->tsc_base = ioremap(res->start, size);
 	if (!tsc->tsc_base) {
 		dev_err(&pdev->dev, "Can't map memory\n");
 		error = -ENOMEM;
 		goto err_release_mem;
 	}

 	tsc->clk = clk_get(&pdev->dev, NULL);
 	if (IS_ERR(tsc->clk)) {
 		dev_err(&pdev->dev, "failed getting clock\n");
 		error = PTR_ERR(tsc->clk);
 		goto err_unmap;
 	}

 	input->name = MOD_NAME;
 	input->phys = "asr/input0";
 	input->id.bustype = BUS_HOST;
 	input->id.vendor = 0x0001;
 	input->id.product = 0x0002;
 	input->id.version = 0x0100;
 	input->dev.parent = &pdev->dev;
 	input->open = asr_ts_open;
 	input->close = asr_ts_close;

 	__set_bit(EV_ABS, input->evbit);
 	__set_bit(ABS_X, input->absbit);
 	__set_bit(ABS_Y, input->absbit);
 	__set_bit(EV_SYN, input->evbit);
 	__set_bit(EV_KEY, input->evbit);
 	__set_bit(BTN_TOUCH, input->keybit);

 	input_set_abs_params(input, ABS_X, ASR_TSC_MIN_XY_VAL,
 			     ASR_TSC_MAX_XY_VAL, 0, 0);
 	input_set_abs_params(input, ABS_Y, ASR_TSC_MIN_XY_VAL,
 			     ASR_TSC_MAX_XY_VAL, 0, 0);

 	input_set_drvdata(input, tsc);

 	error = request_irq(tsc->down_irq, asr_ts_down_isr,
 			    IRQF_SHARED, pdev->name, tsc);
 	if (error) {
 		dev_err(&pdev->dev, "failed requesting down irq\n");
 		goto err_put_clock;
 	}

 	error = request_irq(tsc->rdy_irq, asr_ts_rdy_isr,
 			    IRQF_SHARED, pdev->name, tsc);
 	if (error) {
 		dev_err(&pdev->dev, "failed requesting rdy irq\n");
 		goto err_free_irq0;
 	}

 	error = request_irq(tsc->up_irq, asr_ts_up_isr,
 			    IRQF_SHARED, pdev->name, tsc);
 	if (error) {
 		dev_err(&pdev->dev, "failed requesting up irq\n");
 		goto err_free_irq1;
 	}

 	error = input_register_device(input);
 	if (error) {
 		dev_err(&pdev->dev, "failed registering input device\n");
 		goto err_free_irq2;
 	}

 	platform_set_drvdata(pdev, tsc);
 	device_init_wakeup(&pdev->dev, 1);
 	timer_setup(&tsc->move_timer, asr_ts_movement_detect, 0);
 	dev_info(&pdev->dev, "bringup ok.\n");
 	return 0;

 err_free_irq2:
 	free_irq(tsc->up_irq, tsc);
 err_free_irq1:
 	free_irq(tsc->rdy_irq, tsc);
 err_free_irq0:
 	free_irq(tsc->down_irq, tsc);
 err_put_clock:
 	clk_put(tsc->clk);
 err_unmap:
 	iounmap(tsc->tsc_base);
 err_release_mem:
 	release_mem_region(res->start, size);
 err_free_mem:
 	input_free_device(input);
 	kfree(tsc);

 	return error;
 }

 static int asr_ts_remove(struct platform_device *pdev)
 {
 	struct asr_tsc *tsc = platform_get_drvdata(pdev);
 	struct resource *res;

 	free_irq(tsc->down_irq, tsc);
 	free_irq(tsc->rdy_irq, tsc);
 	free_irq(tsc->up_irq, tsc);

 	input_unregister_device(tsc->dev);

 	clk_put(tsc->clk);

 	iounmap(tsc->tsc_base);
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	release_mem_region(res->start, resource_size(res));

 	kfree(tsc);

 	return 0;
 }

 #ifdef CONFIG_PM
 static int asr_ts_suspend(struct device *dev)
 {
 	struct asr_tsc *tsc = dev_get_drvdata(dev);
 	struct input_dev *input = tsc->dev;

 	/*
 	 * Suspend and resume can be called when the device hasn't been
 	 * enabled. If there are no users that have the device open, then
 	 * avoid calling the TSC stop and start functions as the TSC
 	 * isn't yet clocked.
 	 */
 	mutex_lock(&input->mutex);

 	if (input->users) {
 		if (device_may_wakeup(dev)) {
 			enable_irq_wake(tsc->down_irq);
 			enable_irq_wake(tsc->rdy_irq);
 			enable_irq_wake(tsc->up_irq);
 		} else
 			asr_stop_tsc(tsc);
 	}

 	mutex_unlock(&input->mutex);

 	return 0;
 }

 static int asr_ts_resume(struct device *dev)
 {
 	struct asr_tsc *tsc = dev_get_drvdata(dev);
 	struct input_dev *input = tsc->dev;

 	mutex_lock(&input->mutex);

 	if (input->users) {
 		if (device_may_wakeup(dev)) {
 			disable_irq_wake(tsc->down_irq);
 			disable_irq_wake(tsc->rdy_irq);
 			disable_irq_wake(tsc->up_irq);
 		} else
 			asr_setup_tsc(tsc);
 	}

 	mutex_unlock(&input->mutex);

 	return 0;
 }

 static const struct dev_pm_ops asr_ts_pm_ops = {
 	.suspend	= asr_ts_suspend,
 	.resume		= asr_ts_resume,
 };
 #define ASR_TS_PM_OPS (&asr_ts_pm_ops)
 #else
 #define ASR_TS_PM_OPS NULL
 #endif

 #ifdef CONFIG_OF
 static const struct of_device_id asr_tsc_of_match[] = {
 	{ .compatible = "asr,tsc", },
 	{ },
 };
 MODULE_DEVICE_TABLE(of, asr_tsc_of_match);
 #endif

 static struct platform_driver asr_ts_driver = {
 	.probe		= asr_ts_probe,
 	.remove		= asr_ts_remove,
 	.driver		= {
 		.name	= MOD_NAME,
 		.pm	= ASR_TS_PM_OPS,
 		.of_match_table = of_match_ptr(asr_tsc_of_match),
 	},
 };
 module_platform_driver(asr_ts_driver);

 MODULE_AUTHOR("Mark Zhang <markzhang@asrmicro.com>");
 MODULE_DESCRIPTION("ASR TSC Driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:asr_ts");
	// SPDX-License-Identifier: GPL-2.0-or-later
	/*
	* ASR built-in touchscreen driver
	*
	* Copyright (C) 2023 ASR
	*/

	#include <linux/platform_device.h>
	#include <linux/input.h>
	#include <linux/interrupt.h>
	#include <linux/module.h>
	#include <linux/clk.h>
	#include <linux/io.h>
	#include <linux/slab.h>
	#include <linux/of.h>
	#include <linux/timer.h>

	/*
	* Touchscreen controller register offsets
	*/
	#define ASR_TSCR 0x0
	#define ASR_TSSR 0x4
	#define ASR_XYDR(x) (0x8 + (x) * 0x4)

	#define ASR_TSSR_DOWN 0
	#define ASR_TSSR_UP 1

	#define ASR_TSC_MIN_XY_VAL 0
	#define ASR_TSC_MAX_XY_VAL 4095
	#define ASR_TSC_DOT_CNT_MAX 8

	#define MOD_NAME "ts-asr"

	#define tsc_readl(dev, reg) \
	__raw_readl((dev)->tsc_base + (reg))
	#define tsc_writel(dev, reg, val) \
	__raw_writel((val), (dev)->tsc_base + (reg))

	struct asr_tp_info {
	int x;
	int y;
	int last_x;
	int last_y;
	};

	struct asr_tsc {
	struct timer_list move_timer;
	struct input_dev *dev;
	void __iomem *tsc_base;
	int rdy_irq;
	int up_irq;
	int down_irq;
	struct clk *clk;
	struct asr_tp_info tp;
	int dummpy_points;
	};

	#define ASR_TSC_MOVE_TIMEOUT 10 /* ms */
	#define ASR_TSC_DUMMY_POINTS 10
	#define ASR_TSC_TP_MARGIN 10

	enum {
	TSC_MODE_IDLE = 0,
	TSC_MODE_WAIT_PRESSDOWN,
	TSC_MODE_WAIT_RISEUP,
	TSC_MODE_WAIT_AUTOMEASURE,
	};
	static void asr_ts_set_mode(struct asr_tsc *tsc, int mode);

	static void asr_ts_movement_detect(struct timer_list *t)
	{
	struct asr_tsc *tsc = from_timer(tsc, t, move_timer);
	u32 val;
	val = tsc_readl(tsc, ASR_TSSR);
	if (val & ASR_TSSR_UP) {
	asr_ts_set_mode(tsc, TSC_MODE_WAIT_PRESSDOWN);
	return;
	}

	asr_ts_set_mode(tsc, TSC_MODE_WAIT_AUTOMEASURE);
	}

	static void asr_ts_adc_init(void)
	{
	void __iomem* apb_spare;
	u32 val;

	apb_spare = ioremap(0xD4090000, SZ_4K);
	if (!apb_spare) {
	pr_err("%s: error to ioremap apb_spare base\n", __func__);
	return;
	}

	val = readl(apb_spare + 0x12c);
	val \|= (1 << 8) \| (1 << 20) \| (1 << 22) \| (0x4 << 24);
	writel(val, apb_spare + 0x12c);
	iounmap(apb_spare);
	}

	static void asr_ts_set_mode(struct asr_tsc *tsc, int mode)
	{
	u32 val;
	val = tsc_readl(tsc, ASR_TSCR);
	val &= ~(0x3 << 1);
	switch (mode) {
	case TSC_MODE_WAIT_PRESSDOWN:
	val &= ~((1 << 8) \| (1 << 7));
	val \|= (1 << 6) \| (1 << 9);
	break;
	case TSC_MODE_WAIT_RISEUP:
	val &= ~((1 << 8) \| (1 << 6));
	val \|= (1 << 7) \| (1 << 9);
	break;
	case TSC_MODE_WAIT_AUTOMEASURE:
	val &= ~((1 << 6) \| (1 << 7) \| (1 << 9));
	val \|= (1 << 8);
	break;
	}
	val \|= (mode << 1);
	tsc_writel(tsc, ASR_TSCR, val);
	}

	static void asr_ts_measure(struct asr_tsc *tsc)
	{
	int i;
	u32 val, meas_x, meas_y, sum_x = 0, sum_y = 0;
	u16 min_x, max_x, min_y, max_y;
	u16 x[ASR_TSC_DOT_CNT_MAX] = {0};
	u16 y[ASR_TSC_DOT_CNT_MAX] = {0};
	struct asr_tp_info tp = (struct asr_tp_info )&tsc->tp;

	for (i = 0; i < ASR_TSC_DOT_CNT_MAX; i++) {
	val = tsc_readl(tsc, ASR_XYDR(i));
	x[i] = val & 0xffff;
	sum_x += x[i];
	if (i == 0 ) {
	min_x = x[0];
	max_x = x[0];
	}
	if (min_x > x[i])
	min_x = x[i];
	if (max_x < x[i])
	max_x = x[i];

	y[i] = (val >> 16) & 0xffff;
	sum_y += y[i];

	if (i == 0 ) {
	min_y = y[0];
	max_y = y[0];
	}
	if (min_y > y[i])
	min_y = y[i];
	if(max_y < y[i])
	max_y = y[i];
	pr_debug(" %s: [%d] (%d, %d)\n", __func__, i, x[i], y[i]);
	}

	meas_x = (sum_x - max_x - min_x) / (ASR_TSC_DOT_CNT_MAX - 2);
	meas_y = (sum_y - max_y - min_y) / (ASR_TSC_DOT_CNT_MAX - 2);

	pr_debug("meas_x: %d, meas_y: %d\n", meas_x, meas_y);
	tp->x = meas_x;
	tp->y = meas_y;
	}

	static irqreturn_t asr_ts_down_isr(int irq, void *dev_id)
	{
	u32 val;
	struct asr_tsc tsc = (struct asr_tsc )dev_id;
	val = tsc_readl(tsc, ASR_TSSR);

	if (val & (1 << 6)) {
	val \|= (1 << 6);
	tsc_writel(tsc, ASR_TSSR, val);
	if (val & ASR_TSSR_UP) {
	asr_ts_set_mode(tsc, TSC_MODE_WAIT_PRESSDOWN);
	return IRQ_HANDLED;
	}

	tsc->dummpy_points = 1;
	asr_ts_set_mode(tsc, TSC_MODE_WAIT_AUTOMEASURE);
	pr_debug("%s: got down irq.\n", __func__);
	} else {
	pr_warn("%s: mismatch irq?\n", __func__);
	}
	return IRQ_HANDLED;
	}

	static irqreturn_t asr_ts_rdy_isr(int irq, void *dev_id)
	{
	u32 val;
	int x, y;
	struct asr_tsc tsc = (struct asr_tsc )dev_id;
	struct input_dev *input = tsc->dev;

	val = tsc_readl(tsc, ASR_TSSR);
	if (val & (1 << 8)) {
	val \|= (1 << 8);
	tsc_writel(tsc, ASR_TSSR, val);
	#if 0
	if (val & ASR_TSSR_UP) {
	asr_ts_set_mode(tsc, TSC_MODE_WAIT_PRESSDOWN);
	return IRQ_HANDLED;
	}
	#endif
	asr_ts_measure(tsc);
	if (tsc->dummpy_points) {
	tsc->dummpy_points++;
	if (tsc->dummpy_points > ASR_TSC_DUMMY_POINTS) {
	tsc->dummpy_points = 0;
	x = tsc->tp.last_x = tsc->tp.x;
	y = tsc->tp.last_y = tsc->tp.y;
	} else
	goto skip;
	} else {
	if (abs(tsc->tp.x - tsc->tp.last_x) < ASR_TSC_TP_MARGIN &&
	abs(tsc->tp.y - tsc->tp.last_y) < ASR_TSC_TP_MARGIN)
	goto skip;
	}

	x = tsc->tp.last_x = tsc->tp.x;
	y = tsc->tp.last_y = tsc->tp.y;

	input_report_abs(input, ABS_X, x);
	input_report_abs(input, ABS_Y, y);
	input_report_key(input, BTN_TOUCH, 1);
	input_sync(input);
	skip:
	asr_ts_set_mode(tsc, TSC_MODE_WAIT_RISEUP);
	mod_timer(&tsc->move_timer, jiffies + msecs_to_jiffies(ASR_TSC_MOVE_TIMEOUT));
	pr_debug("%s: got rdy irq. 0x%x, (%d, %d)\n", __func__, val, tsc->tp.x, tsc->tp.y);
	} else {
	pr_warn("%s: mismatch irq?\n", __func__);
	}
	return IRQ_HANDLED;
	}

	static irqreturn_t asr_ts_up_isr(int irq, void *dev_id)
	{
	u32 val;
	struct asr_tsc tsc = (struct asr_tsc )dev_id;
	struct input_dev *input = tsc->dev;

	val = tsc_readl(tsc, ASR_TSSR);
	if (val & (1 << 7)) {
	val \|= (1 << 7);
	tsc_writel(tsc, ASR_TSSR, val);
	if ((val & 1) == ASR_TSSR_DOWN)
	return IRQ_HANDLED;

	pr_debug("%s: got up irq. (%d, %d)\n", __func__, tsc->tp.x, tsc->tp.y);
	input_report_key(input, BTN_TOUCH, 0);
	input_sync(input);
	asr_ts_set_mode(tsc, TSC_MODE_WAIT_PRESSDOWN);
	} else {
	pr_warn("%s: mismatch irq?\n", __func__);
	}
	return IRQ_HANDLED;
	}

	static void asr_stop_tsc(struct asr_tsc *tsc)
	{
	tsc_writel(tsc, ASR_TSCR, 0);
	clk_disable_unprepare(tsc->clk);
	}

	static int asr_setup_tsc(struct asr_tsc *tsc)
	{
	u32 tmp;
	int err;
	asr_ts_adc_init();

	err = clk_prepare_enable(tsc->clk);
	if (err)
	return err;

	tmp = tsc_readl(tsc, ASR_TSCR);
	tmp \|= (1 << 0); /* enabled tsc */
	tmp \|= 0x7 << 16; /* YD ADC channel slection */
	tmp \|= 0x6 << 11; /* XL ADC channel slection */
	tmp \|= (1 << 8); /* INT_RDY_EN */
	tmp \|= (0x20 << 24);
	tmp \|= (0 << 21); /* XL_PU_RES_SEL */
	tmp \|= ((ASR_TSC_DOT_CNT_MAX - 1) << 3); /* DOT_CNT */
	tsc_writel(tsc, ASR_TSCR, tmp);
	asr_ts_set_mode(tsc, TSC_MODE_WAIT_PRESSDOWN);
	return 0;
	}

	static int asr_ts_open(struct input_dev *dev)
	{
	struct asr_tsc *tsc = input_get_drvdata(dev);
	return asr_setup_tsc(tsc);
	}

	static void asr_ts_close(struct input_dev *dev)
	{
	struct asr_tsc *tsc = input_get_drvdata(dev);
	asr_stop_tsc(tsc);
	}

	static int asr_ts_probe(struct platform_device *pdev)
	{
	struct asr_tsc *tsc;
	struct input_dev *input;
	struct resource *res;
	resource_size_t size;
	int irq0, irq1, irq2;
	int error;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
	dev_err(&pdev->dev, "Can't get memory resource\n");
	return -ENOENT;
	}

	irq0 = platform_get_irq(pdev, 0);
	irq1 = platform_get_irq(pdev, 1);
	irq2 = platform_get_irq(pdev, 2);
	if (irq0 < 0 \|\| irq1 < 0 \|\| irq2 < 0) {
	dev_err(&pdev->dev, "err irq:%d, %d, %d\n", irq0, irq1, irq2);
	return -ENOENT;
	}

	tsc = kzalloc(sizeof(*tsc), GFP_KERNEL);
	input = input_allocate_device();
	if (!tsc \|\| !input) {
	dev_err(&pdev->dev, "failed allocating memory\n");
	error = -ENOMEM;
	goto err_free_mem;
	}

	tsc->dev = input;
	tsc->down_irq = irq0;
	tsc->rdy_irq = irq1;
	tsc->up_irq = irq2;

	size = resource_size(res);

	if (!request_mem_region(res->start, size, pdev->name)) {
	dev_err(&pdev->dev, "TSC registers are not free\n");
	error = -EBUSY;
	goto err_free_mem;
	}

	tsc->tsc_base = ioremap(res->start, size);
	if (!tsc->tsc_base) {
	dev_err(&pdev->dev, "Can't map memory\n");
	error = -ENOMEM;
	goto err_release_mem;
	}

	tsc->clk = clk_get(&pdev->dev, NULL);
	if (IS_ERR(tsc->clk)) {
	dev_err(&pdev->dev, "failed getting clock\n");
	error = PTR_ERR(tsc->clk);
	goto err_unmap;
	}

	input->name = MOD_NAME;
	input->phys = "asr/input0";
	input->id.bustype = BUS_HOST;
	input->id.vendor = 0x0001;
	input->id.product = 0x0002;
	input->id.version = 0x0100;
	input->dev.parent = &pdev->dev;
	input->open = asr_ts_open;
	input->close = asr_ts_close;

	__set_bit(EV_ABS, input->evbit);
	__set_bit(ABS_X, input->absbit);
	__set_bit(ABS_Y, input->absbit);
	__set_bit(EV_SYN, input->evbit);
	__set_bit(EV_KEY, input->evbit);
	__set_bit(BTN_TOUCH, input->keybit);

	input_set_abs_params(input, ABS_X, ASR_TSC_MIN_XY_VAL,
	ASR_TSC_MAX_XY_VAL, 0, 0);
	input_set_abs_params(input, ABS_Y, ASR_TSC_MIN_XY_VAL,
	ASR_TSC_MAX_XY_VAL, 0, 0);

	input_set_drvdata(input, tsc);

	error = request_irq(tsc->down_irq, asr_ts_down_isr,
	IRQF_SHARED, pdev->name, tsc);
	if (error) {
	dev_err(&pdev->dev, "failed requesting down irq\n");
	goto err_put_clock;
	}

	error = request_irq(tsc->rdy_irq, asr_ts_rdy_isr,
	IRQF_SHARED, pdev->name, tsc);
	if (error) {
	dev_err(&pdev->dev, "failed requesting rdy irq\n");
	goto err_free_irq0;
	}

	error = request_irq(tsc->up_irq, asr_ts_up_isr,
	IRQF_SHARED, pdev->name, tsc);
	if (error) {
	dev_err(&pdev->dev, "failed requesting up irq\n");
	goto err_free_irq1;
	}

	error = input_register_device(input);
	if (error) {
	dev_err(&pdev->dev, "failed registering input device\n");
	goto err_free_irq2;
	}

	platform_set_drvdata(pdev, tsc);
	device_init_wakeup(&pdev->dev, 1);
	timer_setup(&tsc->move_timer, asr_ts_movement_detect, 0);
	dev_info(&pdev->dev, "bringup ok.\n");
	return 0;

	err_free_irq2:
	free_irq(tsc->up_irq, tsc);
	err_free_irq1:
	free_irq(tsc->rdy_irq, tsc);
	err_free_irq0:
	free_irq(tsc->down_irq, tsc);
	err_put_clock:
	clk_put(tsc->clk);
	err_unmap:
	iounmap(tsc->tsc_base);
	err_release_mem:
	release_mem_region(res->start, size);
	err_free_mem:
	input_free_device(input);
	kfree(tsc);

	return error;
	}

	static int asr_ts_remove(struct platform_device *pdev)
	{
	struct asr_tsc *tsc = platform_get_drvdata(pdev);
	struct resource *res;

	free_irq(tsc->down_irq, tsc);
	free_irq(tsc->rdy_irq, tsc);
	free_irq(tsc->up_irq, tsc);

	input_unregister_device(tsc->dev);

	clk_put(tsc->clk);

	iounmap(tsc->tsc_base);
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	release_mem_region(res->start, resource_size(res));

	kfree(tsc);

	return 0;
	}

	#ifdef CONFIG_PM
	static int asr_ts_suspend(struct device *dev)
	{
	struct asr_tsc *tsc = dev_get_drvdata(dev);
	struct input_dev *input = tsc->dev;

	/*
	* Suspend and resume can be called when the device hasn't been
	* enabled. If there are no users that have the device open, then
	* avoid calling the TSC stop and start functions as the TSC
	* isn't yet clocked.
	*/
	mutex_lock(&input->mutex);

	if (input->users) {
	if (device_may_wakeup(dev)) {
	enable_irq_wake(tsc->down_irq);
	enable_irq_wake(tsc->rdy_irq);
	enable_irq_wake(tsc->up_irq);
	} else
	asr_stop_tsc(tsc);
	}

	mutex_unlock(&input->mutex);

	return 0;
	}

	static int asr_ts_resume(struct device *dev)
	{
	struct asr_tsc *tsc = dev_get_drvdata(dev);
	struct input_dev *input = tsc->dev;

	mutex_lock(&input->mutex);

	if (input->users) {
	if (device_may_wakeup(dev)) {
	disable_irq_wake(tsc->down_irq);
	disable_irq_wake(tsc->rdy_irq);
	disable_irq_wake(tsc->up_irq);
	} else
	asr_setup_tsc(tsc);
	}

	mutex_unlock(&input->mutex);

	return 0;
	}

	static const struct dev_pm_ops asr_ts_pm_ops = {
	.suspend = asr_ts_suspend,
	.resume = asr_ts_resume,
	};
	#define ASR_TS_PM_OPS (&asr_ts_pm_ops)
	#else
	#define ASR_TS_PM_OPS NULL
	#endif

	#ifdef CONFIG_OF
	static const struct of_device_id asr_tsc_of_match[] = {
	{ .compatible = "asr,tsc", },
	{ },
	};
	MODULE_DEVICE_TABLE(of, asr_tsc_of_match);
	#endif

	static struct platform_driver asr_ts_driver = {
	.probe = asr_ts_probe,
	.remove = asr_ts_remove,
	.driver = {
	.name = MOD_NAME,
	.pm = ASR_TS_PM_OPS,
	.of_match_table = of_match_ptr(asr_tsc_of_match),
	},
	};
	module_platform_driver(asr_ts_driver);

	MODULE_AUTHOR("Mark Zhang <markzhang@asrmicro.com>");
	MODULE_DESCRIPTION("ASR TSC Driver");
	MODULE_LICENSE("GPL");
	MODULE_ALIAS("platform:asr_ts");