[mirror_ubuntu-artful-kernel.git] / drivers / input / touchscreen / bcm_iproc_tsc.c

/*
* Copyright (C) 2015 Broadcom Corporation
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation version 2.
*
* This program is distributed "as is" WITHOUT ANY WARRANTY of any
* kind, whether express or implied; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/keyboard.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <asm/irq.h>
#include <linux/io.h>
#include <linux/clk.h>
#include <linux/serio.h>
#include <linux/mfd/syscon.h>
#include <linux/regmap.h>

#define IPROC_TS_NAME "iproc-ts"

#define PEN_DOWN_STATUS     1
#define PEN_UP_STATUS       0

#define X_MIN               0
#define Y_MIN               0
#define X_MAX               0xFFF
#define Y_MAX               0xFFF

/* Value given by controller for invalid coordinate. */
#define INVALID_COORD       0xFFFFFFFF

/* Register offsets */
#define REGCTL1             0x00
#define REGCTL2             0x04
#define INTERRUPT_THRES     0x08
#define INTERRUPT_MASK      0x0c

#define INTERRUPT_STATUS    0x10
#define CONTROLLER_STATUS   0x14
#define FIFO_DATA           0x18
#define FIFO_DATA_X_Y_MASK  0xFFFF
#define ANALOG_CONTROL      0x1c

#define AUX_DATA            0x20
#define DEBOUNCE_CNTR_STAT  0x24
#define SCAN_CNTR_STAT      0x28
#define REM_CNTR_STAT       0x2c

#define SETTLING_TIMER_STAT 0x30
#define SPARE_REG           0x34
#define SOFT_BYPASS_CONTROL 0x38
#define SOFT_BYPASS_DATA    0x3c


/* Bit values for INTERRUPT_MASK and INTERRUPT_STATUS regs */
#define TS_PEN_INTR_MASK        BIT(0)
#define TS_FIFO_INTR_MASK       BIT(2)

/* Bit values for CONTROLLER_STATUS reg1 */
#define TS_PEN_DOWN             BIT(0)

/* Shift values for control reg1 */
#define SCANNING_PERIOD_SHIFT   24
#define DEBOUNCE_TIMEOUT_SHIFT  16
#define SETTLING_TIMEOUT_SHIFT  8
#define TOUCH_TIMEOUT_SHIFT     0

/* Shift values for coordinates from fifo */
#define X_COORD_SHIFT  0
#define Y_COORD_SHIFT  16

/* Bit values for REGCTL2 */
#define TS_CONTROLLER_EN_BIT    BIT(16)
#define TS_CONTROLLER_AVGDATA_SHIFT 8
#define TS_CONTROLLER_AVGDATA_MASK (0x7 << TS_CONTROLLER_AVGDATA_SHIFT)
#define TS_CONTROLLER_PWR_LDO   BIT(5)
#define TS_CONTROLLER_PWR_ADC   BIT(4)
#define TS_CONTROLLER_PWR_BGP   BIT(3)
#define TS_CONTROLLER_PWR_TS    BIT(2)
#define TS_WIRE_MODE_BIT        BIT(1)

#define dbg_reg(dev, priv, reg) \
do { \
	u32 val; \
	regmap_read(priv->regmap, reg, &val); \
	dev_dbg(dev, "%20s= 0x%08x\n", #reg, val); \
} while (0)

struct tsc_param {
	/* Each step is 1024 us.  Valid 1-256 */
	u32 scanning_period;

	/*  Each step is 512 us.  Valid 0-255 */
	u32 debounce_timeout;

	/*
	 * The settling duration (in ms) is the amount of time the tsc
	 * waits to allow the voltage to settle after turning on the
	 * drivers in detection mode. Valid values: 0-11
	 *   0 =  0.008 ms
	 *   1 =  0.01 ms
	 *   2 =  0.02 ms
	 *   3 =  0.04 ms
	 *   4 =  0.08 ms
	 *   5 =  0.16 ms
	 *   6 =  0.32 ms
	 *   7 =  0.64 ms
	 *   8 =  1.28 ms
	 *   9 =  2.56 ms
	 *   10 = 5.12 ms
	 *   11 = 10.24 ms
	 */
	u32 settling_timeout;

	/* touch timeout in sample counts */
	u32 touch_timeout;

	/*
	 * Number of data samples which are averaged before a final data point
	 * is placed into the FIFO
	 */
	u32 average_data;

	/* FIFO threshold */
	u32 fifo_threshold;

	/* Optional standard touchscreen properties. */
	u32 max_x;
	u32 max_y;
	u32 fuzz_x;
	u32 fuzz_y;
	bool invert_x;
	bool invert_y;
};

struct iproc_ts_priv {
	struct platform_device *pdev;
	struct input_dev *idev;

	struct regmap *regmap;
	struct clk *tsc_clk;

	int  pen_status;
	struct tsc_param cfg_params;
};

/*
 * Set default values the same as hardware reset values
 * except for fifo_threshold with is set to 1.
 */
static const struct tsc_param iproc_default_config = {
	.scanning_period  = 0x5,  /* 1 to 256 */
	.debounce_timeout = 0x28, /* 0 to 255 */
	.settling_timeout = 0x7,  /* 0 to 11 */
	.touch_timeout    = 0xa,  /* 0 to 255 */
	.average_data     = 5,    /* entry 5 = 32 pts */
	.fifo_threshold   = 1,    /* 0 to 31 */
	.max_x            = X_MAX,
	.max_y            = Y_MAX,
};

static void ts_reg_dump(struct iproc_ts_priv *priv)
{
	struct device *dev = &priv->pdev->dev;

	dbg_reg(dev, priv, REGCTL1);
	dbg_reg(dev, priv, REGCTL2);
	dbg_reg(dev, priv, INTERRUPT_THRES);
	dbg_reg(dev, priv, INTERRUPT_MASK);
	dbg_reg(dev, priv, INTERRUPT_STATUS);
	dbg_reg(dev, priv, CONTROLLER_STATUS);
	dbg_reg(dev, priv, FIFO_DATA);
	dbg_reg(dev, priv, ANALOG_CONTROL);
	dbg_reg(dev, priv, AUX_DATA);
	dbg_reg(dev, priv, DEBOUNCE_CNTR_STAT);
	dbg_reg(dev, priv, SCAN_CNTR_STAT);
	dbg_reg(dev, priv, REM_CNTR_STAT);
	dbg_reg(dev, priv, SETTLING_TIMER_STAT);
	dbg_reg(dev, priv, SPARE_REG);
	dbg_reg(dev, priv, SOFT_BYPASS_CONTROL);
	dbg_reg(dev, priv, SOFT_BYPASS_DATA);
}

static irqreturn_t iproc_touchscreen_interrupt(int irq, void *data)
{
	struct platform_device *pdev = data;
	struct iproc_ts_priv *priv = platform_get_drvdata(pdev);
	u32 intr_status;
	u32 raw_coordinate;
	u16 x;
	u16 y;
	int i;
	bool needs_sync = false;

	regmap_read(priv->regmap, INTERRUPT_STATUS, &intr_status);
	intr_status &= TS_PEN_INTR_MASK | TS_FIFO_INTR_MASK;
	if (intr_status == 0)
		return IRQ_NONE;

	/* Clear all interrupt status bits, write-1-clear */
	regmap_write(priv->regmap, INTERRUPT_STATUS, intr_status);
	/* Pen up/down */
	if (intr_status & TS_PEN_INTR_MASK) {
		regmap_read(priv->regmap, CONTROLLER_STATUS, &priv->pen_status);
		if (priv->pen_status & TS_PEN_DOWN)
			priv->pen_status = PEN_DOWN_STATUS;
		else
			priv->pen_status = PEN_UP_STATUS;

		input_report_key(priv->idev, BTN_TOUCH,	priv->pen_status);
		needs_sync = true;

		dev_dbg(&priv->pdev->dev,
			"pen up-down (%d)\n", priv->pen_status);
	}

	/* coordinates in FIFO exceed the theshold */
	if (intr_status & TS_FIFO_INTR_MASK) {
		for (i = 0; i < priv->cfg_params.fifo_threshold; i++) {
			regmap_read(priv->regmap, FIFO_DATA, &raw_coordinate);
			if (raw_coordinate == INVALID_COORD)
				continue;

			/*
			 * The x and y coordinate are 16 bits each
			 * with the x in the lower 16 bits and y in the
			 * upper 16 bits.
			 */
			x = (raw_coordinate >> X_COORD_SHIFT) &
				FIFO_DATA_X_Y_MASK;
			y = (raw_coordinate >> Y_COORD_SHIFT) &
				FIFO_DATA_X_Y_MASK;

			/* We only want to retain the 12 msb of the 16 */
			x = (x >> 4) & 0x0FFF;
			y = (y >> 4) & 0x0FFF;

			/* Adjust x y according to LCD tsc mount angle. */
			if (priv->cfg_params.invert_x)
				x = priv->cfg_params.max_x - x;

			if (priv->cfg_params.invert_y)
				y = priv->cfg_params.max_y - y;

			input_report_abs(priv->idev, ABS_X, x);
			input_report_abs(priv->idev, ABS_Y, y);
			needs_sync = true;

			dev_dbg(&priv->pdev->dev, "xy (0x%x 0x%x)\n", x, y);
		}
	}

	if (needs_sync)
		input_sync(priv->idev);

	return IRQ_HANDLED;
}

static int iproc_ts_start(struct input_dev *idev)
{
	u32 val;
	u32 mask;
	int error;
	struct iproc_ts_priv *priv = input_get_drvdata(idev);

	/* Enable clock */
	error = clk_prepare_enable(priv->tsc_clk);
	if (error) {
		dev_err(&priv->pdev->dev, "%s clk_prepare_enable failed %d\n",
			__func__, error);
		return error;
	}

	/*
	 * Interrupt is generated when:
	 *  FIFO reaches the int_th value, and pen event(up/down)
	 */
	val = TS_PEN_INTR_MASK | TS_FIFO_INTR_MASK;
	regmap_update_bits(priv->regmap, INTERRUPT_MASK, val, val);

	val = priv->cfg_params.fifo_threshold;
	regmap_write(priv->regmap, INTERRUPT_THRES, val);

	/* Initialize control reg1 */
	val = 0;
	val |= priv->cfg_params.scanning_period << SCANNING_PERIOD_SHIFT;
	val |= priv->cfg_params.debounce_timeout << DEBOUNCE_TIMEOUT_SHIFT;
	val |= priv->cfg_params.settling_timeout << SETTLING_TIMEOUT_SHIFT;
	val |= priv->cfg_params.touch_timeout << TOUCH_TIMEOUT_SHIFT;
	regmap_write(priv->regmap, REGCTL1, val);

	/* Try to clear all interrupt status */
	val = TS_FIFO_INTR_MASK | TS_PEN_INTR_MASK;
	regmap_update_bits(priv->regmap, INTERRUPT_STATUS, val, val);

	/* Initialize control reg2 */
	val = TS_CONTROLLER_EN_BIT | TS_WIRE_MODE_BIT;
	val |= priv->cfg_params.average_data << TS_CONTROLLER_AVGDATA_SHIFT;

	mask = (TS_CONTROLLER_AVGDATA_MASK);
	mask |= (TS_CONTROLLER_PWR_LDO |	/* PWR up LDO */
		   TS_CONTROLLER_PWR_ADC |	/* PWR up ADC */
		   TS_CONTROLLER_PWR_BGP |	/* PWR up BGP */
		   TS_CONTROLLER_PWR_TS);	/* PWR up TS */
	mask |= val;
	regmap_update_bits(priv->regmap, REGCTL2, mask, val);

	ts_reg_dump(priv);

	return 0;
}

static void iproc_ts_stop(struct input_dev *dev)
{
	u32 val;
	struct iproc_ts_priv *priv = input_get_drvdata(dev);

	/*
	 * Disable FIFO int_th and pen event(up/down)Interrupts only
	 * as the interrupt mask register is shared between ADC, TS and
	 * flextimer.
	 */
	val = TS_PEN_INTR_MASK | TS_FIFO_INTR_MASK;
	regmap_update_bits(priv->regmap, INTERRUPT_MASK, val, 0);

	/* Only power down touch screen controller */
	val = TS_CONTROLLER_PWR_TS;
	regmap_update_bits(priv->regmap, REGCTL2, val, val);

	clk_disable(priv->tsc_clk);
}

static int iproc_get_tsc_config(struct device *dev, struct iproc_ts_priv *priv)
{
	struct device_node *np = dev->of_node;
	u32 val;

	priv->cfg_params = iproc_default_config;

	if (!np)
		return 0;

	if (of_property_read_u32(np, "scanning_period", &val) >= 0) {
		if (val < 1 || val > 256) {
			dev_err(dev, "scanning_period (%u) must be [1-256]\n",
				val);
			return -EINVAL;
		}
		priv->cfg_params.scanning_period = val;
	}

	if (of_property_read_u32(np, "debounce_timeout", &val) >= 0) {
		if (val > 255) {
			dev_err(dev, "debounce_timeout (%u) must be [0-255]\n",
				val);
			return -EINVAL;
		}
		priv->cfg_params.debounce_timeout = val;
	}

	if (of_property_read_u32(np, "settling_timeout", &val) >= 0) {
		if (val > 11) {
			dev_err(dev, "settling_timeout (%u) must be [0-11]\n",
				val);
			return -EINVAL;
		}
		priv->cfg_params.settling_timeout = val;
	}

	if (of_property_read_u32(np, "touch_timeout", &val) >= 0) {
		if (val > 255) {
			dev_err(dev, "touch_timeout (%u) must be [0-255]\n",
				val);
			return -EINVAL;
		}
		priv->cfg_params.touch_timeout = val;
	}

	if (of_property_read_u32(np, "average_data", &val) >= 0) {
		if (val > 8) {
			dev_err(dev, "average_data (%u) must be [0-8]\n", val);
			return -EINVAL;
		}
		priv->cfg_params.average_data = val;
	}

	if (of_property_read_u32(np, "fifo_threshold", &val) >= 0) {
		if (val > 31) {
			dev_err(dev, "fifo_threshold (%u)) must be [0-31]\n",
				val);
			return -EINVAL;
		}
		priv->cfg_params.fifo_threshold = val;
	}

	/* Parse optional properties. */
	of_property_read_u32(np, "touchscreen-size-x", &priv->cfg_params.max_x);
	of_property_read_u32(np, "touchscreen-size-y", &priv->cfg_params.max_y);

	of_property_read_u32(np, "touchscreen-fuzz-x",
			     &priv->cfg_params.fuzz_x);
	of_property_read_u32(np, "touchscreen-fuzz-y",
			     &priv->cfg_params.fuzz_y);

	priv->cfg_params.invert_x =
		of_property_read_bool(np, "touchscreen-inverted-x");
	priv->cfg_params.invert_y =
		of_property_read_bool(np, "touchscreen-inverted-y");

	return 0;
}

static int iproc_ts_probe(struct platform_device *pdev)
{
	struct iproc_ts_priv *priv;
	struct input_dev *idev;
	int irq;
	int error;

	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	/* touchscreen controller memory mapped regs via syscon*/
	priv->regmap = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
							"ts_syscon");
	if (IS_ERR(priv->regmap)) {
		error = PTR_ERR(priv->regmap);
		dev_err(&pdev->dev, "unable to map I/O memory:%d\n", error);
		return error;
	}

	priv->tsc_clk = devm_clk_get(&pdev->dev, "tsc_clk");
	if (IS_ERR(priv->tsc_clk)) {
		error = PTR_ERR(priv->tsc_clk);
		dev_err(&pdev->dev,
			"failed getting clock tsc_clk: %d\n", error);
		return error;
	}

	priv->pdev = pdev;
	error = iproc_get_tsc_config(&pdev->dev, priv);
	if (error) {
		dev_err(&pdev->dev, "get_tsc_config failed: %d\n", error);
		return error;
	}

	idev = devm_input_allocate_device(&pdev->dev);
	if (!idev) {
		dev_err(&pdev->dev, "failed to allocate input device\n");
		return -ENOMEM;
	}

	priv->idev = idev;
	priv->pen_status = PEN_UP_STATUS;

	/* Set input device info  */
	idev->name = IPROC_TS_NAME;
	idev->dev.parent = &pdev->dev;

	idev->id.bustype = BUS_HOST;
	idev->id.vendor = SERIO_UNKNOWN;
	idev->id.product = 0;
	idev->id.version = 0;

	idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
	__set_bit(BTN_TOUCH, idev->keybit);

	input_set_abs_params(idev, ABS_X, X_MIN, priv->cfg_params.max_x,
			     priv->cfg_params.fuzz_x, 0);
	input_set_abs_params(idev, ABS_Y, Y_MIN, priv->cfg_params.max_y,
			     priv->cfg_params.fuzz_y, 0);

	idev->open = iproc_ts_start;
	idev->close = iproc_ts_stop;

	input_set_drvdata(idev, priv);
	platform_set_drvdata(pdev, priv);

	/* get interrupt */
	irq = platform_get_irq(pdev, 0);
	if (irq < 0) {
		dev_err(&pdev->dev, "platform_get_irq failed: %d\n", irq);
		return irq;
	}

	error = devm_request_irq(&pdev->dev, irq,
				 iproc_touchscreen_interrupt,
				 IRQF_SHARED, IPROC_TS_NAME, pdev);
	if (error)
		return error;

	error = input_register_device(priv->idev);
	if (error) {
		dev_err(&pdev->dev,
			"failed to register input device: %d\n", error);
		return error;
	}

	return 0;
}

static const struct of_device_id iproc_ts_of_match[] = {
	{.compatible = "brcm,iproc-touchscreen", },
	{ },
};
MODULE_DEVICE_TABLE(of, iproc_ts_of_match);

static struct platform_driver iproc_ts_driver = {
	.probe = iproc_ts_probe,
	.driver = {
		.name	= IPROC_TS_NAME,
		.of_match_table = of_match_ptr(iproc_ts_of_match),
	},
};

module_platform_driver(iproc_ts_driver);

MODULE_DESCRIPTION("IPROC Touchscreen driver");
MODULE_AUTHOR("Broadcom");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
d5ae685f JR	1	/*
	2	* Copyright (C) 2015 Broadcom Corporation
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License as
	6	* published by the Free Software Foundation version 2.
	7	*
	8	* This program is distributed "as is" WITHOUT ANY WARRANTY of any
	9	* kind, whether express or implied; without even the implied warranty
	10	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*/
	13	#include <linux/module.h>
	14	#include <linux/init.h>
	15	#include <linux/input.h>
	16	#include <linux/delay.h>
	17	#include <linux/interrupt.h>
	18	#include <linux/keyboard.h>
	19	#include <linux/platform_device.h>
	20	#include <linux/slab.h>
	21	#include <linux/of.h>
	22	#include <asm/irq.h>
	23	#include <linux/io.h>
	24	#include <linux/clk.h>
	25	#include <linux/serio.h>
74813ceb RP	26	#include <linux/mfd/syscon.h>
74813ceb RP	27	#include <linux/regmap.h>
d5ae685f JR	28
	29	#define IPROC_TS_NAME "iproc-ts"
	30
	31	#define PEN_DOWN_STATUS 1
	32	#define PEN_UP_STATUS 0
	33
	34	#define X_MIN 0
	35	#define Y_MIN 0
	36	#define X_MAX 0xFFF
	37	#define Y_MAX 0xFFF
	38
	39	/* Value given by controller for invalid coordinate. */
	40	#define INVALID_COORD 0xFFFFFFFF
	41
	42	/* Register offsets */
	43	#define REGCTL1 0x00
	44	#define REGCTL2 0x04
	45	#define INTERRUPT_THRES 0x08
	46	#define INTERRUPT_MASK 0x0c
	47
	48	#define INTERRUPT_STATUS 0x10
	49	#define CONTROLLER_STATUS 0x14
	50	#define FIFO_DATA 0x18
	51	#define FIFO_DATA_X_Y_MASK 0xFFFF
	52	#define ANALOG_CONTROL 0x1c
	53
	54	#define AUX_DATA 0x20
	55	#define DEBOUNCE_CNTR_STAT 0x24
	56	#define SCAN_CNTR_STAT 0x28
	57	#define REM_CNTR_STAT 0x2c
	58
	59	#define SETTLING_TIMER_STAT 0x30
	60	#define SPARE_REG 0x34
	61	#define SOFT_BYPASS_CONTROL 0x38
	62	#define SOFT_BYPASS_DATA 0x3c
	63
	64
	65	/* Bit values for INTERRUPT_MASK and INTERRUPT_STATUS regs */
	66	#define TS_PEN_INTR_MASK BIT(0)
	67	#define TS_FIFO_INTR_MASK BIT(2)
	68
	69	/* Bit values for CONTROLLER_STATUS reg1 */
	70	#define TS_PEN_DOWN BIT(0)
	71
	72	/* Shift values for control reg1 */
	73	#define SCANNING_PERIOD_SHIFT 24
	74	#define DEBOUNCE_TIMEOUT_SHIFT 16
	75	#define SETTLING_TIMEOUT_SHIFT 8
	76	#define TOUCH_TIMEOUT_SHIFT 0
	77
	78	/* Shift values for coordinates from fifo */
	79	#define X_COORD_SHIFT 0
	80	#define Y_COORD_SHIFT 16
	81
	82	/* Bit values for REGCTL2 */
	83	#define TS_CONTROLLER_EN_BIT BIT(16)
	84	#define TS_CONTROLLER_AVGDATA_SHIFT 8
	85	#define TS_CONTROLLER_AVGDATA_MASK (0x7 << TS_CONTROLLER_AVGDATA_SHIFT)
	86	#define TS_CONTROLLER_PWR_LDO BIT(5)
	87	#define TS_CONTROLLER_PWR_ADC BIT(4)
	88	#define TS_CONTROLLER_PWR_BGP BIT(3)
	89	#define TS_CONTROLLER_PWR_TS BIT(2)
	90	#define TS_WIRE_MODE_BIT BIT(1)
	91
92	#define dbg_reg(dev, priv, reg) \
74813ceb RP	93	do { \
	94	u32 val; \
	95	regmap_read(priv->regmap, reg, &val); \
	96	dev_dbg(dev, "%20s= 0x%08x\n", #reg, val); \
	97	} while (0)
d5ae685f JR	98
	99	struct tsc_param {
	100	/* Each step is 1024 us. Valid 1-256 */
	101	u32 scanning_period;
	102
	103	/* Each step is 512 us. Valid 0-255 */
	104	u32 debounce_timeout;
	105
	106	/*
	107	* The settling duration (in ms) is the amount of time the tsc
	108	* waits to allow the voltage to settle after turning on the
	109	* drivers in detection mode. Valid values: 0-11
	110	* 0 = 0.008 ms
	111	* 1 = 0.01 ms
	112	* 2 = 0.02 ms
	113	* 3 = 0.04 ms
	114	* 4 = 0.08 ms
	115	* 5 = 0.16 ms
	116	* 6 = 0.32 ms
	117	* 7 = 0.64 ms
	118	* 8 = 1.28 ms
	119	* 9 = 2.56 ms
	120	* 10 = 5.12 ms
	121	* 11 = 10.24 ms
	122	*/
	123	u32 settling_timeout;
	124
	125	/* touch timeout in sample counts */
	126	u32 touch_timeout;
	127
	128	/*
	129	* Number of data samples which are averaged before a final data point
	130	* is placed into the FIFO
	131	*/
	132	u32 average_data;
	133
	134	/* FIFO threshold */
	135	u32 fifo_threshold;
	136
	137	/* Optional standard touchscreen properties. */
	138	u32 max_x;
	139	u32 max_y;
	140	u32 fuzz_x;
	141	u32 fuzz_y;
	142	bool invert_x;
	143	bool invert_y;
	144	};
	145
	146	struct iproc_ts_priv {
	147	struct platform_device *pdev;
	148	struct input_dev *idev;
	149
74813ceb	150	struct regmap *regmap;
d5ae685f JR	151	struct clk *tsc_clk;
	152
	153	int pen_status;
	154	struct tsc_param cfg_params;
	155	};
	156
	157	/*
	158	* Set default values the same as hardware reset values
	159	* except for fifo_threshold with is set to 1.
	160	*/
	161	static const struct tsc_param iproc_default_config = {
	162	.scanning_period = 0x5, /* 1 to 256 */
	163	.debounce_timeout = 0x28, /* 0 to 255 */
	164	.settling_timeout = 0x7, /* 0 to 11 */
	165	.touch_timeout = 0xa, /* 0 to 255 */
	166	.average_data = 5, /* entry 5 = 32 pts */
	167	.fifo_threshold = 1, /* 0 to 31 */
	168	.max_x = X_MAX,
	169	.max_y = Y_MAX,
	170	};
	171
	172	static void ts_reg_dump(struct iproc_ts_priv *priv)
	173	{
	174	struct device *dev = &priv->pdev->dev;
	175
	176	dbg_reg(dev, priv, REGCTL1);
	177	dbg_reg(dev, priv, REGCTL2);
	178	dbg_reg(dev, priv, INTERRUPT_THRES);
	179	dbg_reg(dev, priv, INTERRUPT_MASK);
	180	dbg_reg(dev, priv, INTERRUPT_STATUS);
	181	dbg_reg(dev, priv, CONTROLLER_STATUS);
	182	dbg_reg(dev, priv, FIFO_DATA);
	183	dbg_reg(dev, priv, ANALOG_CONTROL);
	184	dbg_reg(dev, priv, AUX_DATA);
	185	dbg_reg(dev, priv, DEBOUNCE_CNTR_STAT);
	186	dbg_reg(dev, priv, SCAN_CNTR_STAT);
	187	dbg_reg(dev, priv, REM_CNTR_STAT);
	188	dbg_reg(dev, priv, SETTLING_TIMER_STAT);
	189	dbg_reg(dev, priv, SPARE_REG);
	190	dbg_reg(dev, priv, SOFT_BYPASS_CONTROL);
	191	dbg_reg(dev, priv, SOFT_BYPASS_DATA);
	192	}
	193
	194	static irqreturn_t iproc_touchscreen_interrupt(int irq, void *data)
	195	{
	196	struct platform_device *pdev = data;
	197	struct iproc_ts_priv *priv = platform_get_drvdata(pdev);
	198	u32 intr_status;
	199	u32 raw_coordinate;
	200	u16 x;
	201	u16 y;
	202	int i;
	203	bool needs_sync = false;
	204
74813ceb	205	regmap_read(priv->regmap, INTERRUPT_STATUS, &intr_status);
d5ae685f JR	206	intr_status &= TS_PEN_INTR_MASK \| TS_FIFO_INTR_MASK;
	207	if (intr_status == 0)
	208	return IRQ_NONE;
	209
	210	/* Clear all interrupt status bits, write-1-clear */
74813ceb	211	regmap_write(priv->regmap, INTERRUPT_STATUS, intr_status);
d5ae685f JR	212	/* Pen up/down */
d5ae685f JR	213	if (intr_status & TS_PEN_INTR_MASK) {
74813ceb RP	214	regmap_read(priv->regmap, CONTROLLER_STATUS, &priv->pen_status);
74813ceb RP	215	if (priv->pen_status & TS_PEN_DOWN)
d5ae685f JR	216	priv->pen_status = PEN_DOWN_STATUS;
	217	else
	218	priv->pen_status = PEN_UP_STATUS;
	219
74813ceb	220	input_report_key(priv->idev, BTN_TOUCH, priv->pen_status);
d5ae685f JR	221	needs_sync = true;
	222
	223	dev_dbg(&priv->pdev->dev,
	224	"pen up-down (%d)\n", priv->pen_status);
	225	}
	226
	227	/* coordinates in FIFO exceed the theshold */
	228	if (intr_status & TS_FIFO_INTR_MASK) {
	229	for (i = 0; i < priv->cfg_params.fifo_threshold; i++) {
74813ceb	230	regmap_read(priv->regmap, FIFO_DATA, &raw_coordinate);
d5ae685f JR	231	if (raw_coordinate == INVALID_COORD)
	232	continue;
	233
	234	/*
	235	* The x and y coordinate are 16 bits each
	236	* with the x in the lower 16 bits and y in the
	237	* upper 16 bits.
	238	*/
	239	x = (raw_coordinate >> X_COORD_SHIFT) &
	240	FIFO_DATA_X_Y_MASK;
	241	y = (raw_coordinate >> Y_COORD_SHIFT) &
	242	FIFO_DATA_X_Y_MASK;
	243
	244	/* We only want to retain the 12 msb of the 16 */
	245	x = (x >> 4) & 0x0FFF;
	246	y = (y >> 4) & 0x0FFF;
	247
74813ceb	248	/* Adjust x y according to LCD tsc mount angle. */
d5ae685f JR	249	if (priv->cfg_params.invert_x)
	250	x = priv->cfg_params.max_x - x;
	251
	252	if (priv->cfg_params.invert_y)
	253	y = priv->cfg_params.max_y - y;
	254
	255	input_report_abs(priv->idev, ABS_X, x);
	256	input_report_abs(priv->idev, ABS_Y, y);
	257	needs_sync = true;
	258
	259	dev_dbg(&priv->pdev->dev, "xy (0x%x 0x%x)\n", x, y);
	260	}
	261	}
	262
	263	if (needs_sync)
	264	input_sync(priv->idev);
	265
	266	return IRQ_HANDLED;
	267	}
	268
	269	static int iproc_ts_start(struct input_dev *idev)
	270	{
d5ae685f	271	u32 val;
74813ceb	272	u32 mask;
d5ae685f	273	int error;
74813ceb	274	struct iproc_ts_priv *priv = input_get_drvdata(idev);
d5ae685f JR	275
	276	/* Enable clock */
	277	error = clk_prepare_enable(priv->tsc_clk);
	278	if (error) {
	279	dev_err(&priv->pdev->dev, "%s clk_prepare_enable failed %d\n",
	280	__func__, error);
	281	return error;
	282	}
	283
	284	/*
	285	* Interrupt is generated when:
	286	* FIFO reaches the int_th value, and pen event(up/down)
	287	*/
	288	val = TS_PEN_INTR_MASK \| TS_FIFO_INTR_MASK;
74813ceb	289	regmap_update_bits(priv->regmap, INTERRUPT_MASK, val, val);
d5ae685f	290
74813ceb RP	291	val = priv->cfg_params.fifo_threshold;
74813ceb RP	292	regmap_write(priv->regmap, INTERRUPT_THRES, val);
d5ae685f JR	293
	294	/* Initialize control reg1 */
	295	val = 0;
	296	val \|= priv->cfg_params.scanning_period << SCANNING_PERIOD_SHIFT;
	297	val \|= priv->cfg_params.debounce_timeout << DEBOUNCE_TIMEOUT_SHIFT;
	298	val \|= priv->cfg_params.settling_timeout << SETTLING_TIMEOUT_SHIFT;
	299	val \|= priv->cfg_params.touch_timeout << TOUCH_TIMEOUT_SHIFT;
74813ceb	300	regmap_write(priv->regmap, REGCTL1, val);
d5ae685f JR	301
d5ae685f JR	302	/* Try to clear all interrupt status */
74813ceb RP	303	val = TS_FIFO_INTR_MASK \| TS_PEN_INTR_MASK;
74813ceb RP	304	regmap_update_bits(priv->regmap, INTERRUPT_STATUS, val, val);
d5ae685f JR	305
d5ae685f JR	306	/* Initialize control reg2 */
74813ceb	307	val = TS_CONTROLLER_EN_BIT \| TS_WIRE_MODE_BIT;
d5ae685f JR	308	val \|= priv->cfg_params.average_data << TS_CONTROLLER_AVGDATA_SHIFT;
d5ae685f JR	309
74813ceb RP	310	mask = (TS_CONTROLLER_AVGDATA_MASK);
74813ceb RP	311	mask \|= (TS_CONTROLLER_PWR_LDO \| /* PWR up LDO */
d5ae685f JR	312	TS_CONTROLLER_PWR_ADC \| /* PWR up ADC */
	313	TS_CONTROLLER_PWR_BGP \| /* PWR up BGP */
	314	TS_CONTROLLER_PWR_TS); /* PWR up TS */
74813ceb RP	315	mask \|= val;
74813ceb RP	316	regmap_update_bits(priv->regmap, REGCTL2, mask, val);
d5ae685f JR	317
	318	ts_reg_dump(priv);
	319
	320	return 0;
	321	}
	322
	323	static void iproc_ts_stop(struct input_dev *dev)
	324	{
	325	u32 val;
	326	struct iproc_ts_priv *priv = input_get_drvdata(dev);
	327
74813ceb RP	328	/*
	329	* Disable FIFO int_th and pen event(up/down)Interrupts only
	330	* as the interrupt mask register is shared between ADC, TS and
	331	* flextimer.
	332	*/
	333	val = TS_PEN_INTR_MASK \| TS_FIFO_INTR_MASK;
	334	regmap_update_bits(priv->regmap, INTERRUPT_MASK, val, 0);
d5ae685f JR	335
d5ae685f JR	336	/* Only power down touch screen controller */
74813ceb RP	337	val = TS_CONTROLLER_PWR_TS;
74813ceb RP	338	regmap_update_bits(priv->regmap, REGCTL2, val, val);
d5ae685f JR	339
	340	clk_disable(priv->tsc_clk);
	341	}
	342
	343	static int iproc_get_tsc_config(struct device dev, struct iproc_ts_priv priv)
	344	{
	345	struct device_node *np = dev->of_node;
	346	u32 val;
	347
	348	priv->cfg_params = iproc_default_config;
	349
	350	if (!np)
	351	return 0;
	352
	353	if (of_property_read_u32(np, "scanning_period", &val) >= 0) {
	354	if (val < 1 \|\| val > 256) {
	355	dev_err(dev, "scanning_period (%u) must be [1-256]\n",
	356	val);
	357	return -EINVAL;
	358	}
	359	priv->cfg_params.scanning_period = val;
	360	}
	361
	362	if (of_property_read_u32(np, "debounce_timeout", &val) >= 0) {
	363	if (val > 255) {
	364	dev_err(dev, "debounce_timeout (%u) must be [0-255]\n",
	365	val);
	366	return -EINVAL;
	367	}
	368	priv->cfg_params.debounce_timeout = val;
	369	}
	370
	371	if (of_property_read_u32(np, "settling_timeout", &val) >= 0) {
	372	if (val > 11) {
	373	dev_err(dev, "settling_timeout (%u) must be [0-11]\n",
	374	val);
	375	return -EINVAL;
	376	}
	377	priv->cfg_params.settling_timeout = val;
	378	}
	379
	380	if (of_property_read_u32(np, "touch_timeout", &val) >= 0) {
	381	if (val > 255) {
	382	dev_err(dev, "touch_timeout (%u) must be [0-255]\n",
	383	val);
	384	return -EINVAL;
	385	}
	386	priv->cfg_params.touch_timeout = val;
	387	}
	388
	389	if (of_property_read_u32(np, "average_data", &val) >= 0) {
	390	if (val > 8) {
	391	dev_err(dev, "average_data (%u) must be [0-8]\n", val);
	392	return -EINVAL;
	393	}
	394	priv->cfg_params.average_data = val;
	395	}
	396
	397	if (of_property_read_u32(np, "fifo_threshold", &val) >= 0) {
	398	if (val > 31) {
	399	dev_err(dev, "fifo_threshold (%u)) must be [0-31]\n",
	400	val);
	401	return -EINVAL;
	402	}
403	priv->cfg_params.fifo_threshold = val;
404	}
405
406	/* Parse optional properties. */
407	of_property_read_u32(np, "touchscreen-size-x", &priv->cfg_params.max_x);
408	of_property_read_u32(np, "touchscreen-size-y", &priv->cfg_params.max_y);
409
410	of_property_read_u32(np, "touchscreen-fuzz-x",
411	&priv->cfg_params.fuzz_x);
412	of_property_read_u32(np, "touchscreen-fuzz-y",
413	&priv->cfg_params.fuzz_y);
414
415	priv->cfg_params.invert_x =
416	of_property_read_bool(np, "touchscreen-inverted-x");
417	priv->cfg_params.invert_y =
418	of_property_read_bool(np, "touchscreen-inverted-y");
419
420	return 0;
421	}
422
423	static int iproc_ts_probe(struct platform_device *pdev)
424	{
425	struct iproc_ts_priv *priv;
426	struct input_dev *idev;
d5ae685f JR	427	int irq;
	428	int error;
	429
	430	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
	431	if (!priv)
	432	return -ENOMEM;
	433
74813ceb RP	434	/* touchscreen controller memory mapped regs via syscon*/
	435	priv->regmap = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
	436	"ts_syscon");
	437	if (IS_ERR(priv->regmap)) {
	438	error = PTR_ERR(priv->regmap);
	439	dev_err(&pdev->dev, "unable to map I/O memory:%d\n", error);
d5ae685f JR	440	return error;
	441	}
	442
	443	priv->tsc_clk = devm_clk_get(&pdev->dev, "tsc_clk");
	444	if (IS_ERR(priv->tsc_clk)) {
	445	error = PTR_ERR(priv->tsc_clk);
	446	dev_err(&pdev->dev,
	447	"failed getting clock tsc_clk: %d\n", error);
	448	return error;
	449	}
	450
	451	priv->pdev = pdev;
	452	error = iproc_get_tsc_config(&pdev->dev, priv);
	453	if (error) {
	454	dev_err(&pdev->dev, "get_tsc_config failed: %d\n", error);
	455	return error;
	456	}
	457
	458	idev = devm_input_allocate_device(&pdev->dev);
	459	if (!idev) {
	460	dev_err(&pdev->dev, "failed to allocate input device\n");
	461	return -ENOMEM;
	462	}
	463
	464	priv->idev = idev;
	465	priv->pen_status = PEN_UP_STATUS;
	466
	467	/* Set input device info */
	468	idev->name = IPROC_TS_NAME;
	469	idev->dev.parent = &pdev->dev;
	470
	471	idev->id.bustype = BUS_HOST;
	472	idev->id.vendor = SERIO_UNKNOWN;
	473	idev->id.product = 0;
	474	idev->id.version = 0;
	475
	476	idev->evbit[0] = BIT_MASK(EV_KEY) \| BIT_MASK(EV_ABS);
	477	__set_bit(BTN_TOUCH, idev->keybit);
	478
	479	input_set_abs_params(idev, ABS_X, X_MIN, priv->cfg_params.max_x,
	480	priv->cfg_params.fuzz_x, 0);
	481	input_set_abs_params(idev, ABS_Y, Y_MIN, priv->cfg_params.max_y,
	482	priv->cfg_params.fuzz_y, 0);
	483
	484	idev->open = iproc_ts_start;
	485	idev->close = iproc_ts_stop;
	486
	487	input_set_drvdata(idev, priv);
	488	platform_set_drvdata(pdev, priv);
	489
	490	/* get interrupt */
	491	irq = platform_get_irq(pdev, 0);
	492	if (irq < 0) {
	493	dev_err(&pdev->dev, "platform_get_irq failed: %d\n", irq);
	494	return irq;
	495	}
	496
	497	error = devm_request_irq(&pdev->dev, irq,
	498	iproc_touchscreen_interrupt,
	499	IRQF_SHARED, IPROC_TS_NAME, pdev);
	500	if (error)
	501	return error;
	502
	503	error = input_register_device(priv->idev);
504	if (error) {
505	dev_err(&pdev->dev,
506	"failed to register input device: %d\n", error);
507	return error;
508	}
509
510	return 0;
511	}
512
513	static const struct of_device_id iproc_ts_of_match[] = {
514	{.compatible = "brcm,iproc-touchscreen", },
515	{ },
516	};
517	MODULE_DEVICE_TABLE(of, iproc_ts_of_match);
518
519	static struct platform_driver iproc_ts_driver = {
520	.probe = iproc_ts_probe,
521	.driver = {
522	.name = IPROC_TS_NAME,
523	.of_match_table = of_match_ptr(iproc_ts_of_match),
524	},
525	};
526
527	module_platform_driver(iproc_ts_driver);
528
529	MODULE_DESCRIPTION("IPROC Touchscreen driver");
530	MODULE_AUTHOR("Broadcom");
531	MODULE_LICENSE("GPL v2");