[MIPS] db1x00: Remove unused mirage_ts.c

# Makefile for the Alchemy Semiconductor Db1x00 board.

lib-y := init.o board_setup.o irqmap.o

obj-$(CONFIG_WM97XX_COMODULE) += mirage_ts.o

/*

 * 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);