[mirror_ubuntu-jammy-kernel.git] / arch / mips / au1000 / db1x00 / mirage_ts.c

/*
 * linux/arch/mips/au1000/db1x00/mirage_ts.c
 *
 * BRIEF MODULE DESCRIPTION
 *	Glue between Mirage board-specific touchscreen pieces
 *	and generic Wolfson Codec touchscreen support.
 *
 *	Based on pb1100_ts.c used in Hydrogen II.
 *
 * Copyright (c) 2003 Embedded Edge, LLC
 *		dan@embeddededge.com
 *
 *  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;  either version 2 of the	License, or (at your
 *  option) any later version.
 *
 *  THIS  SOFTWARE  IS PROVIDED	  ``AS	IS'' AND   ANY	EXPRESS OR IMPLIED
 *  WARRANTIES,	  INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
 *  NO	EVENT  SHALL   THE AUTHOR  BE	 LIABLE FOR ANY	  DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 *  NOT LIMITED	  TO, PROCUREMENT OF  SUBSTITUTE GOODS	OR SERVICES; LOSS OF
 *  USE, DATA,	OR PROFITS; OR	BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 *  ANY THEORY OF LIABILITY, WHETHER IN	 CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *  You should have received a copy of the  GNU General Public License along
 *  with this program; if not, write  to the Free Software Foundation, Inc.,
 *  675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/types.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/poll.h>
#include <linux/proc_fs.h>
#include <linux/smp.h>
#include <linux/smp_lock.h>
#include <linux/wait.h>

#include <asm/segment.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
#include <asm/delay.h>
#include <asm/au1000.h>

/*
 *  Imported interface to Wolfson Codec driver.
 */
extern void *wm97xx_ts_get_handle(int which);
extern int wm97xx_ts_ready(void* ts_handle);
extern void wm97xx_ts_set_cal(void* ts_handle, int xscale, int xtrans, int yscale, int ytrans);
extern u16 wm97xx_ts_get_ac97(void* ts_handle, u8 reg);
extern void wm97xx_ts_set_ac97(void* ts_handle, u8 reg, u16 val);
extern int wm97xx_ts_read_data(void* ts_handle, long* x, long* y, long* pressure);
extern void wm97xx_ts_send_data(void* ts_handle, long x, long y, long z);

int wm97xx_comodule_present = 1;


#define TS_NAME "mirage_ts"

#define err(format, arg...) printk(KERN_ERR TS_NAME ": " format "\n" , ## arg)
#define info(format, arg...) printk(KERN_INFO TS_NAME ": " format "\n" , ## arg)
#define warn(format, arg...) printk(KERN_WARNING TS_NAME ": " format "\n" , ## arg)
#define DPRINTK(format, arg...) printk("%s: " format "\n", __FUNCTION__ , ## arg)


#define PEN_DOWN_IRQ	AU1000_GPIO_7

static struct task_struct *ts_task = 0;
static DECLARE_COMPLETION(ts_complete);
static DECLARE_WAIT_QUEUE_HEAD(pendown_wait);

#ifdef CONFIG_WM97XX_FIVEWIRETS
static int release_pressure = 1;
#else
static int release_pressure = 50;
#endif

typedef struct {
   long x;
   long y;
} DOWN_EVENT;

#define SAMPLE_RATE	50	/* samples per second */
#define PEN_DEBOUNCE	5	/* samples for settling - fn of SAMPLE_RATE */
#define PEN_UP_TIMEOUT	10	/* in seconds */
#define PEN_UP_SETTLE	5	/* samples per second */

static struct {
	int xscale;
	int xtrans;
	int yscale;
	int ytrans;
} mirage_ts_cal =
{
#if 0
	.xscale   = 84,
	.xtrans = -157,
	.yscale   = 66,
	.ytrans = -150,
#else
	.xscale   = 84,
	.xtrans = -150,
	.yscale   = 66,
	.ytrans = -146,
#endif
};


static void pendown_irq(int irqnr, void *devid, struct pt_regs *regs)
{
//DPRINTK("got one 0x%x", au_readl(SYS_PINSTATERD));
	wake_up(&pendown_wait);
}

static int ts_thread(void *id)
{
	static int pen_was_down = 0;
	static DOWN_EVENT pen_xy;
	long x, y, z;
	void *ts;	/* handle */
	struct task_struct *tsk = current;
	int timeout = HZ / SAMPLE_RATE;

	ts_task = tsk;

	daemonize();
	tsk->tty = NULL;
	tsk->policy = SCHED_FIFO;
	tsk->rt_priority = 1;
	strcpy(tsk->comm, "touchscreen");

	/* only want to receive SIGKILL */
	spin_lock_irq(&tsk->sigmask_lock);
	siginitsetinv(&tsk->blocked, sigmask(SIGKILL));
	recalc_sigpending(tsk);
	spin_unlock_irq(&tsk->sigmask_lock);

	/* get handle for codec */
	ts = wm97xx_ts_get_handle(0);

	/* proceed only after everybody is ready */
	wait_event_timeout(pendown_wait, wm97xx_ts_ready(ts), HZ/4);

	/* board-specific calibration */
	wm97xx_ts_set_cal(ts,
			mirage_ts_cal.xscale,
			mirage_ts_cal.xtrans,
			mirage_ts_cal.yscale,
			mirage_ts_cal.ytrans);

	/* route Wolfson pendown interrupts to our GPIO */
	au_sync();
	wm97xx_ts_set_ac97(ts, 0x4c, wm97xx_ts_get_ac97(ts, 0x4c) & ~0x0008);
	au_sync();
	wm97xx_ts_set_ac97(ts, 0x56, wm97xx_ts_get_ac97(ts, 0x56) & ~0x0008);
	au_sync();
	wm97xx_ts_set_ac97(ts, 0x52, wm97xx_ts_get_ac97(ts, 0x52) | 0x2008);
	au_sync();

	for (;;) {
		interruptible_sleep_on_timeout(&pendown_wait, timeout);
		disable_irq(PEN_DOWN_IRQ);
		if (signal_pending(tsk)) {
			break;
		}

		/* read codec */
		if (!wm97xx_ts_read_data(ts, &x, &y, &z))
			z = 0;	/* treat no-data and pen-up the same */

		if (signal_pending(tsk)) {
			break;
		}

		if (z >= release_pressure) {
			y = ~y;	/* top to bottom */
			if (pen_was_down > 1 /*&& pen_was_down < PEN_DEBOUNCE*/) {//THXXX
				/* bounce ? */
				x = pen_xy.x;
				y = pen_xy.y;
				--pen_was_down;
			} else if (pen_was_down <= 1) {
				pen_xy.x = x;
				pen_xy.y = y;
				if (pen_was_down)
					wm97xx_ts_send_data(ts, x, y, z);
				pen_was_down = PEN_DEBOUNCE;
			}
			//wm97xx_ts_send_data(ts, x, y, z);
			timeout = HZ / SAMPLE_RATE;
		} else {
			if (pen_was_down) {
				if (--pen_was_down)
					z = release_pressure;
				else //THXXX
				wm97xx_ts_send_data(ts, pen_xy.x, pen_xy.y, z);
			}
			/* The pendown signal takes some time to settle after
			 * reading the pen pressure so wait a little
			 * before enabling the pen.
			 */
			if (! pen_was_down) {
//				interruptible_sleep_on_timeout(&pendown_wait, HZ / PEN_UP_SETTLE);
				timeout = HZ * PEN_UP_TIMEOUT;
			}
		}
		enable_irq(PEN_DOWN_IRQ);
	}
	enable_irq(PEN_DOWN_IRQ);
	ts_task = NULL;
	complete(&ts_complete);
	return 0;
}

static int __init ts_mirage_init(void)
{
	int ret;

	/* pen down signal is connected to GPIO 7 */

	ret = request_irq(PEN_DOWN_IRQ, pendown_irq, 0, "ts-pendown", NULL);
	if (ret) {
		err("unable to get pendown irq%d: [%d]", PEN_DOWN_IRQ, ret);
		return ret;
	}

	lock_kernel();
	ret = kernel_thread(ts_thread, NULL, CLONE_FS | CLONE_FILES);
	if (ret < 0) {
		unlock_kernel();
		return ret;
	}
	unlock_kernel();

	info("Mirage touchscreen IRQ initialized.");

	return 0;
}

static void __exit ts_mirage_exit(void)
{
	if (ts_task) {
		send_sig(SIGKILL, ts_task, 1);
		wait_for_completion(&ts_complete);
	}

	free_irq(PEN_DOWN_IRQ, NULL);
}

module_init(ts_mirage_init);
module_exit(ts_mirage_exit);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/mips/au1000/db1x00/mirage_ts.c
	3	*
	4	* BRIEF MODULE DESCRIPTION
	5	* Glue between Mirage board-specific touchscreen pieces
	6	* and generic Wolfson Codec touchscreen support.
	7	*
	8	* Based on pb1100_ts.c used in Hydrogen II.
	9	*
	10	* Copyright (c) 2003 Embedded Edge, LLC
	11	* dan@embeddededge.com
	12	*
	13	* This program is free software; you can redistribute it and/or modify it
	14	* under the terms of the GNU General Public License as published by the
	15	* Free Software Foundation; either version 2 of the License, or (at your
	16	* option) any later version.
	17	*
	18	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
	19	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	20	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
	21	* NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
	24	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
	25	* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	28	*
	29	* You should have received a copy of the GNU General Public License along
	30	* with this program; if not, write to the Free Software Foundation, Inc.,
	31	* 675 Mass Ave, Cambridge, MA 02139, USA.
	32	*/
	33
1da177e4 LT	34	#include <linux/types.h>
	35	#include <linux/module.h>
	36	#include <linux/sched.h>
	37	#include <linux/kernel.h>
	38	#include <linux/init.h>
	39	#include <linux/fs.h>
	40	#include <linux/poll.h>
	41	#include <linux/proc_fs.h>
	42	#include <linux/smp.h>
	43	#include <linux/smp_lock.h>
	44	#include <linux/wait.h>
	45
	46	#include <asm/segment.h>
	47	#include <asm/irq.h>
	48	#include <asm/uaccess.h>
	49	#include <asm/delay.h>
	50	#include <asm/au1000.h>
	51
	52	/*
	53	* Imported interface to Wolfson Codec driver.
	54	*/
	55	extern void *wm97xx_ts_get_handle(int which);
	56	extern int wm97xx_ts_ready(void* ts_handle);
	57	extern void wm97xx_ts_set_cal(void* ts_handle, int xscale, int xtrans, int yscale, int ytrans);
	58	extern u16 wm97xx_ts_get_ac97(void* ts_handle, u8 reg);
	59	extern void wm97xx_ts_set_ac97(void* ts_handle, u8 reg, u16 val);
	60	extern int wm97xx_ts_read_data(void* ts_handle, long* x, long* y, long* pressure);
	61	extern void wm97xx_ts_send_data(void* ts_handle, long x, long y, long z);
	62
	63	int wm97xx_comodule_present = 1;
	64
	65
	66	#define TS_NAME "mirage_ts"
	67
	68	#define err(format, arg...) printk(KERN_ERR TS_NAME ": " format "\n" , ## arg)
	69	#define info(format, arg...) printk(KERN_INFO TS_NAME ": " format "\n" , ## arg)
	70	#define warn(format, arg...) printk(KERN_WARNING TS_NAME ": " format "\n" , ## arg)
	71	#define DPRINTK(format, arg...) printk("%s: " format "\n", __FUNCTION__ , ## arg)
	72
	73
	74	#define PEN_DOWN_IRQ AU1000_GPIO_7
	75
	76	static struct task_struct *ts_task = 0;
	77	static DECLARE_COMPLETION(ts_complete);
	78	static DECLARE_WAIT_QUEUE_HEAD(pendown_wait);
	79
	80	#ifdef CONFIG_WM97XX_FIVEWIRETS
	81	static int release_pressure = 1;
	82	#else
	83	static int release_pressure = 50;
	84	#endif
	85
	86	typedef struct {
	87	long x;
	88	long y;
	89	} DOWN_EVENT;
	90
	91	#define SAMPLE_RATE 50 /* samples per second */
	92	#define PEN_DEBOUNCE 5 /* samples for settling - fn of SAMPLE_RATE */
	93	#define PEN_UP_TIMEOUT 10 /* in seconds */
	94	#define PEN_UP_SETTLE 5 /* samples per second */
	95
	96	static struct {
	97	int xscale;
98	int xtrans;
99	int yscale;
100	int ytrans;
101	} mirage_ts_cal =
102	{
103	#if 0
0f04afb5 RB	104	.xscale = 84,
	105	.xtrans = -157,
	106	.yscale = 66,
	107	.ytrans = -150,
1da177e4	108	#else
0f04afb5 RB	109	.xscale = 84,
	110	.xtrans = -150,
	111	.yscale = 66,
	112	.ytrans = -146,
1da177e4 LT	113	#endif
	114	};
	115
	116
	117	static void pendown_irq(int irqnr, void devid, struct pt_regs regs)
	118	{
	119	//DPRINTK("got one 0x%x", au_readl(SYS_PINSTATERD));
	120	wake_up(&pendown_wait);
	121	}
	122
	123	static int ts_thread(void *id)
	124	{
	125	static int pen_was_down = 0;
	126	static DOWN_EVENT pen_xy;
	127	long x, y, z;
	128	void ts; / handle */
	129	struct task_struct *tsk = current;
	130	int timeout = HZ / SAMPLE_RATE;
	131
	132	ts_task = tsk;
	133
	134	daemonize();
	135	tsk->tty = NULL;
	136	tsk->policy = SCHED_FIFO;
	137	tsk->rt_priority = 1;
	138	strcpy(tsk->comm, "touchscreen");
	139
	140	/* only want to receive SIGKILL */
	141	spin_lock_irq(&tsk->sigmask_lock);
	142	siginitsetinv(&tsk->blocked, sigmask(SIGKILL));
	143	recalc_sigpending(tsk);
	144	spin_unlock_irq(&tsk->sigmask_lock);
	145
	146	/* get handle for codec */
	147	ts = wm97xx_ts_get_handle(0);
	148
	149	/* proceed only after everybody is ready */
	150	wait_event_timeout(pendown_wait, wm97xx_ts_ready(ts), HZ/4);
	151
	152	/* board-specific calibration */
	153	wm97xx_ts_set_cal(ts,
	154	mirage_ts_cal.xscale,
	155	mirage_ts_cal.xtrans,
	156	mirage_ts_cal.yscale,
	157	mirage_ts_cal.ytrans);
	158
	159	/* route Wolfson pendown interrupts to our GPIO */
	160	au_sync();
	161	wm97xx_ts_set_ac97(ts, 0x4c, wm97xx_ts_get_ac97(ts, 0x4c) & ~0x0008);
	162	au_sync();
	163	wm97xx_ts_set_ac97(ts, 0x56, wm97xx_ts_get_ac97(ts, 0x56) & ~0x0008);
	164	au_sync();
	165	wm97xx_ts_set_ac97(ts, 0x52, wm97xx_ts_get_ac97(ts, 0x52) \| 0x2008);
	166	au_sync();
	167
	168	for (;;) {
	169	interruptible_sleep_on_timeout(&pendown_wait, timeout);
	170	disable_irq(PEN_DOWN_IRQ);
	171	if (signal_pending(tsk)) {
	172	break;
	173	}
	174
	175	/* read codec */
	176	if (!wm97xx_ts_read_data(ts, &x, &y, &z))
177	z = 0; /* treat no-data and pen-up the same */
178
179	if (signal_pending(tsk)) {
180	break;
181	}
182
183	if (z >= release_pressure) {
184	y = ~y; /* top to bottom */
185	if (pen_was_down > 1 /&& pen_was_down < PEN_DEBOUNCE/) {//THXXX
186	/* bounce ? */
187	x = pen_xy.x;
188	y = pen_xy.y;
189	--pen_was_down;
190	} else if (pen_was_down <= 1) {
191	pen_xy.x = x;
192	pen_xy.y = y;
193	if (pen_was_down)
194	wm97xx_ts_send_data(ts, x, y, z);
195	pen_was_down = PEN_DEBOUNCE;
196	}
197	//wm97xx_ts_send_data(ts, x, y, z);
198	timeout = HZ / SAMPLE_RATE;
199	} else {
200	if (pen_was_down) {
201	if (--pen_was_down)
202	z = release_pressure;
203	else //THXXX
204	wm97xx_ts_send_data(ts, pen_xy.x, pen_xy.y, z);
205	}
206	/* The pendown signal takes some time to settle after
207	* reading the pen pressure so wait a little
208	* before enabling the pen.
209	*/
210	if (! pen_was_down) {
211	// interruptible_sleep_on_timeout(&pendown_wait, HZ / PEN_UP_SETTLE);
212	timeout = HZ * PEN_UP_TIMEOUT;
213	}
214	}
215	enable_irq(PEN_DOWN_IRQ);
216	}
217	enable_irq(PEN_DOWN_IRQ);
218	ts_task = NULL;
219	complete(&ts_complete);
220	return 0;
221	}
222
223	static int __init ts_mirage_init(void)
224	{
225	int ret;
226
227	/* pen down signal is connected to GPIO 7 */
228
229	ret = request_irq(PEN_DOWN_IRQ, pendown_irq, 0, "ts-pendown", NULL);
230	if (ret) {
231	err("unable to get pendown irq%d: [%d]", PEN_DOWN_IRQ, ret);
232	return ret;
233	}
234
235	lock_kernel();
236	ret = kernel_thread(ts_thread, NULL, CLONE_FS \| CLONE_FILES);
237	if (ret < 0) {
238	unlock_kernel();
239	return ret;
240	}
241	unlock_kernel();
242
243	info("Mirage touchscreen IRQ initialized.");
244
245	return 0;
246	}
247
248	static void __exit ts_mirage_exit(void)
249	{
250	if (ts_task) {
251	send_sig(SIGKILL, ts_task, 1);
252	wait_for_completion(&ts_complete);
253	}
254
255	free_irq(PEN_DOWN_IRQ, NULL);
256	}
257
258	module_init(ts_mirage_init);
259	module_exit(ts_mirage_exit);
260