domenico/openwrt_NSS_ACW
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

bump to 2.6.30-rc6

Browse Source 
SVN-Revision: 15918
This commit is contained in:
Lars-Peter Clausen
2009-05-18 17:55:41 +00:00
parent 267af10b33
commit f5affd4f36
159 changed files with 55656 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

593
target/linux/s3c24xx/files-2.6.30/drivers/input/touchscreen/s3c2410_ts.c Normal file
View File

@@ -0,0 +1,593 @@
/*
* 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 program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Copyright (c) 2004 Arnaud Patard <arnaud.patard@rtp-net.org>
* iPAQ H1940 touchscreen support
*
* ChangeLog
*
* 2004-09-05: Herbert Pötzl <herbert@13thfloor.at>
* - added clock (de-)allocation code
*
* 2005-03-06: Arnaud Patard <arnaud.patard@rtp-net.org>
* - h1940_ -> s3c2410 (this driver is now also used on the n30
* machines :P)
* - Debug messages are now enabled with the config option
* TOUCHSCREEN_S3C2410_DEBUG
* - Changed the way the value are read
* - Input subsystem should now work
* - Use ioremap and readl/writel
*
* 2005-03-23: Arnaud Patard <arnaud.patard@rtp-net.org>
* - Make use of some undocumented features of the touchscreen
* controller
*
* 2007-05-23: Harald Welte <laforge@openmoko.org>
* - Add proper support for S32440
*
* 2008-06-23: Andy Green <andy@openmoko.com>
* - removed averaging system
* - added generic Touchscreen filter stuff
*
* 2008-11-27: Nelson Castillo <arhuaco@freaks-unidos.net>
* - improve interrupt handling
*/
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/init.h>
#include <linux/serio.h>
#include <linux/timer.h>
#include <linux/kfifo.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <mach/regs-gpio.h>
#include <mach/ts.h>
#include <mach/hardware.h>
#include <plat/regs-adc.h>
#include <linux/touchscreen/ts_filter_chain.h>
/* For ts.dev.id.version */
#define S3C2410TSVERSION 0x0101
#define TSC_SLEEP (S3C2410_ADCTSC_PULL_UP_DISABLE | S3C2410_ADCTSC_XY_PST(0))
#define WAIT4INT(x) (((x)<<8) | \
S3C2410_ADCTSC_YM_SEN | \
S3C2410_ADCTSC_YP_SEN | \
S3C2410_ADCTSC_XP_SEN | \
S3C2410_ADCTSC_XY_PST(3))
#define AUTOPST (S3C2410_ADCTSC_YM_SEN | \
S3C2410_ADCTSC_YP_SEN | \
S3C2410_ADCTSC_XP_SEN | \
S3C2410_ADCTSC_AUTO_PST | \
S3C2410_ADCTSC_XY_PST(0))
#define DEBUG_LVL KERN_DEBUG
MODULE_AUTHOR("Arnaud Patard <arnaud.patard@rtp-net.org>");
MODULE_DESCRIPTION("s3c2410 touchscreen driver");
MODULE_LICENSE("GPL");
/*
* Definitions & global arrays.
*/
static char *s3c2410ts_name = "s3c2410 TouchScreen";
#define TS_RELEASE_TIMEOUT (HZ >> 7 ? HZ >> 7 : 1) /* 8ms (5ms if HZ is 200) */
#define TS_EVENT_FIFO_SIZE (2 << 6) /* must be a power of 2 */
#define TS_STATE_STANDBY 0 /* initial state */
#define TS_STATE_PRESSED 1
#define TS_STATE_RELEASE_PENDING 2
#define TS_STATE_RELEASE 3
/*
* Per-touchscreen data.
*/
struct s3c2410ts {
struct input_dev *dev;
struct ts_filter_chain *chain;
int is_down;
int state;
struct kfifo *event_fifo;
};
static struct s3c2410ts ts;
static void __iomem *base_addr;
/*
* A few low level functions.
*/
static inline void s3c2410_ts_connect(void)
{
s3c2410_gpio_cfgpin(S3C2410_GPG12, S3C2410_GPG12_XMON);
s3c2410_gpio_cfgpin(S3C2410_GPG13, S3C2410_GPG13_nXPON);
s3c2410_gpio_cfgpin(S3C2410_GPG14, S3C2410_GPG14_YMON);
s3c2410_gpio_cfgpin(S3C2410_GPG15, S3C2410_GPG15_nYPON);
}
static void s3c2410_ts_start_adc_conversion(void)
{
writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST,
base_addr + S3C2410_ADCTSC);
writel(readl(base_addr + S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START,
base_addr + S3C2410_ADCCON);
}
/*
* Just send the input events.
*/
enum ts_input_event {IE_DOWN = 0, IE_UP};
static void ts_input_report(int event, int coords[])
{
#ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG
static char *s[] = {"down", "up"};
struct timeval tv;
do_gettimeofday(&tv);
#endif
if (event == IE_DOWN) {
input_report_abs(ts.dev, ABS_X, coords[0]);
input_report_abs(ts.dev, ABS_Y, coords[1]);
input_report_key(ts.dev, BTN_TOUCH, 1);
input_report_abs(ts.dev, ABS_PRESSURE, 1);
#ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG
printk(DEBUG_LVL "T:%06d %6s (X:%03d, Y:%03d)\n",
(int)tv.tv_usec, s[event], coords[0], coords[1]);
#endif
} else {
input_report_key(ts.dev, BTN_TOUCH, 0);
input_report_abs(ts.dev, ABS_PRESSURE, 0);
#ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG
printk(DEBUG_LVL "T:%06d %6s\n",
(int)tv.tv_usec, s[event]);
#endif
}
input_sync(ts.dev);
}
/*
* Manage the state of the touchscreen.
*/
static void event_send_timer_f(unsigned long data);
static struct timer_list event_send_timer =
TIMER_INITIALIZER(event_send_timer_f, 0, 0);
static void event_send_timer_f(unsigned long data)
{
static int noop_counter;
int event_type;
while (__kfifo_get(ts.event_fifo, (unsigned char *)&event_type,
sizeof(int))) {
int buf[2];
switch (event_type) {
case 'D':
if (ts.state == TS_STATE_RELEASE_PENDING)
/* Ignore short UP event */
ts.state = TS_STATE_PRESSED;
break;
case 'U':
ts.state = TS_STATE_RELEASE_PENDING;
break;
case 'P':
if (ts.is_down) /* stylus_action needs a conversion */
s3c2410_ts_start_adc_conversion();
if (unlikely(__kfifo_get(ts.event_fifo,
(unsigned char *)buf,
sizeof(int) * 2)
!= sizeof(int) * 2))
goto ts_exit_error;
ts_input_report(IE_DOWN, buf);
ts.state = TS_STATE_PRESSED;
break;
default:
goto ts_exit_error;
}
noop_counter = 0;
}
if (noop_counter++ >= 1) {
noop_counter = 0;
if (ts.state == TS_STATE_RELEASE_PENDING) {
/*
* We delay the UP event for a while to avoid jitter.
* If we get a DOWN event we do not send it.
*/
ts_input_report(IE_UP, NULL);
ts.state = TS_STATE_STANDBY;
ts_filter_chain_clear(ts.chain);
}
} else {
mod_timer(&event_send_timer, jiffies + TS_RELEASE_TIMEOUT);
}
return;
ts_exit_error: /* should not happen unless we have a bug */
printk(KERN_ERR __FILE__ ": event_send_timer_f failed\n");
}
/*
* Manage interrupts.
*/
static irqreturn_t stylus_updown(int irq, void *dev_id)
{
unsigned long data0;
unsigned long data1;
int event_type;
data0 = readl(base_addr+S3C2410_ADCDAT0);
data1 = readl(base_addr+S3C2410_ADCDAT1);
ts.is_down = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) &&
(!(data1 & S3C2410_ADCDAT0_UPDOWN));
event_type = ts.is_down ? 'D' : 'U';
if (unlikely(__kfifo_put(ts.event_fifo, (unsigned char *)&event_type,
sizeof(int)) != sizeof(int))) /* should not happen */
printk(KERN_ERR __FILE__": stylus_updown lost event!\n");
if (ts.is_down)
s3c2410_ts_start_adc_conversion();
else
writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC);
mod_timer(&event_send_timer, jiffies + 1);
return IRQ_HANDLED;
}
static irqreturn_t stylus_action(int irq, void *dev_id)
{
int buf[3];
/* Grab the ADC results. */
buf[1] = readl(base_addr + S3C2410_ADCDAT0) &
S3C2410_ADCDAT0_XPDATA_MASK;
buf[2] = readl(base_addr + S3C2410_ADCDAT1) &
S3C2410_ADCDAT1_YPDATA_MASK;
switch (ts_filter_chain_feed(ts.chain, &buf[1])) {
case 0:
/* The filter wants more points. */
s3c2410_ts_start_adc_conversion();
return IRQ_HANDLED;
case 1:
/* We have a point from the filters or no filtering enabled. */
buf[0] = 'P';
break;
default:
printk(KERN_ERR __FILE__
":%d Invalid ts_filter_chain_feed return value.\n",
__LINE__);
case -1:
/* Error. Ignore the event. */
ts_filter_chain_clear(ts.chain);
writel(WAIT4INT(1), base_addr + S3C2410_ADCTSC);
return IRQ_HANDLED;
};
if (unlikely(__kfifo_put(ts.event_fifo, (unsigned char *)buf,
sizeof(int) * 3) != sizeof(int) * 3))
printk(KERN_ERR __FILE__":stylus_action bug.\n");
writel(WAIT4INT(1), base_addr + S3C2410_ADCTSC);
mod_timer(&event_send_timer, jiffies + 1);
return IRQ_HANDLED;
}
static struct clk *adc_clock;
/*
* The functions for inserting/removing us as a module.
*/
static int __init s3c2410ts_probe(struct platform_device *pdev)
{
int rc;
struct s3c2410_ts_mach_info *info;
struct input_dev *input_dev;
int ret = 0;
dev_info(&pdev->dev, "Starting\n");
info = (struct s3c2410_ts_mach_info *)pdev->dev.platform_data;
if (!info)
{
dev_err(&pdev->dev, "Hm... too bad: no platform data for ts\n");
return -EINVAL;
}
#ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG
printk(DEBUG_LVL "Entering s3c2410ts_init\n");
#endif
adc_clock = clk_get(NULL, "adc");
if (!adc_clock) {
dev_err(&pdev->dev, "failed to get adc clock source\n");
return -ENOENT;
}
clk_enable(adc_clock);
#ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG
printk(DEBUG_LVL "got and enabled clock\n");
#endif
base_addr = ioremap(S3C2410_PA_ADC,0x20);
if (base_addr == NULL) {
dev_err(&pdev->dev, "Failed to remap register block\n");
ret = -ENOMEM;
goto bail0;
}
/* If we acutally are a S3C2410: Configure GPIOs */
if (!strcmp(pdev->name, "s3c2410-ts"))
s3c2410_ts_connect();
if ((info->presc & 0xff) > 0)
writel(S3C2410_ADCCON_PRSCEN |
S3C2410_ADCCON_PRSCVL(info->presc&0xFF),
base_addr + S3C2410_ADCCON);
else
writel(0, base_addr+S3C2410_ADCCON);
/* Initialise registers */
if ((info->delay & 0xffff) > 0)
writel(info->delay & 0xffff, base_addr + S3C2410_ADCDLY);
writel(WAIT4INT(0), base_addr + S3C2410_ADCTSC);
/* Initialise input stuff */
memset(&ts, 0, sizeof(struct s3c2410ts));
input_dev = input_allocate_device();
if (!input_dev) {
dev_err(&pdev->dev, "Unable to allocate the input device\n");
ret = -ENOMEM;
goto bail1;
}
ts.dev = input_dev;
ts.dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) |
BIT_MASK(EV_ABS);
ts.dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
input_set_abs_params(ts.dev, ABS_X, 0, 0x3FF, 0, 0);
input_set_abs_params(ts.dev, ABS_Y, 0, 0x3FF, 0, 0);
input_set_abs_params(ts.dev, ABS_PRESSURE, 0, 1, 0, 0);
ts.dev->name = s3c2410ts_name;
ts.dev->id.bustype = BUS_RS232;
ts.dev->id.vendor = 0xDEAD;
ts.dev->id.product = 0xBEEF;
ts.dev->id.version = S3C2410TSVERSION;
ts.state = TS_STATE_STANDBY;
ts.event_fifo = kfifo_alloc(TS_EVENT_FIFO_SIZE, GFP_KERNEL, NULL);
if (IS_ERR(ts.event_fifo)) {
ret = -EIO;
goto bail2;
}
/* create the filter chain set up for the 2 coordinates we produce */
ts.chain = ts_filter_chain_create(pdev, info->filter_config, 2);
if (IS_ERR(ts.chain))
goto bail2;
ts_filter_chain_clear(ts.chain);
/* Get irqs */
if (request_irq(IRQ_ADC, stylus_action, IRQF_SAMPLE_RANDOM,
"s3c2410_action", ts.dev)) {
dev_err(&pdev->dev, "Could not allocate ts IRQ_ADC !\n");
iounmap(base_addr);
ret = -EIO;
goto bail3;
}
if (request_irq(IRQ_TC, stylus_updown, IRQF_SAMPLE_RANDOM,
"s3c2410_action", ts.dev)) {
dev_err(&pdev->dev, "Could not allocate ts IRQ_TC !\n");
free_irq(IRQ_ADC, ts.dev);
iounmap(base_addr);
ret = -EIO;
goto bail4;
}
dev_info(&pdev->dev, "Successfully loaded\n");
/* All went ok, so register to the input system */
rc = input_register_device(ts.dev);
if (rc) {
ret = -EIO;
goto bail5;
}
return 0;
bail5:
free_irq(IRQ_TC, ts.dev);
free_irq(IRQ_ADC, ts.dev);
clk_disable(adc_clock);
iounmap(base_addr);
disable_irq(IRQ_TC);
bail4:
disable_irq(IRQ_ADC);
bail3:
ts_filter_chain_destroy(ts.chain);
kfifo_free(ts.event_fifo);
bail2:
input_unregister_device(ts.dev);
bail1:
iounmap(base_addr);
bail0:
return ret;
}
static int s3c2410ts_remove(struct platform_device *pdev)
{
disable_irq(IRQ_ADC);
disable_irq(IRQ_TC);
free_irq(IRQ_TC,ts.dev);
free_irq(IRQ_ADC,ts.dev);
if (adc_clock) {
clk_disable(adc_clock);
clk_put(adc_clock);
adc_clock = NULL;
}
input_unregister_device(ts.dev);
iounmap(base_addr);
ts_filter_chain_destroy(ts.chain);
kfifo_free(ts.event_fifo);
return 0;
}
#ifdef CONFIG_PM
static int s3c2410ts_suspend(struct platform_device *pdev, pm_message_t state)
{
writel(TSC_SLEEP, base_addr+S3C2410_ADCTSC);
writel(readl(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_STDBM,
base_addr+S3C2410_ADCCON);
disable_irq(IRQ_ADC);
disable_irq(IRQ_TC);
clk_disable(adc_clock);
return 0;
}
static int s3c2410ts_resume(struct platform_device *pdev)
{
struct s3c2410_ts_mach_info *info =
( struct s3c2410_ts_mach_info *)pdev->dev.platform_data;
clk_enable(adc_clock);
mdelay(1);
ts_filter_chain_clear(ts.chain);
enable_irq(IRQ_ADC);
enable_irq(IRQ_TC);
if ((info->presc&0xff) > 0)
writel(S3C2410_ADCCON_PRSCEN |
S3C2410_ADCCON_PRSCVL(info->presc&0xFF),
base_addr+S3C2410_ADCCON);
else
writel(0,base_addr+S3C2410_ADCCON);
/* Initialise registers */
if ((info->delay & 0xffff) > 0)
writel(info->delay & 0xffff, base_addr+S3C2410_ADCDLY);
writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC);
return 0;
}
#else
#define s3c2410ts_suspend NULL
#define s3c2410ts_resume NULL
#endif
static struct platform_driver s3c2410ts_driver = {
.driver = {
.name = "s3c2410-ts",
.owner = THIS_MODULE,
},
.probe = s3c2410ts_probe,
.remove = s3c2410ts_remove,
.suspend = s3c2410ts_suspend,
.resume = s3c2410ts_resume,
};
static struct platform_driver s3c2440ts_driver = {
.driver = {
.name = "s3c2440-ts",
.owner = THIS_MODULE,
},
.probe = s3c2410ts_probe,
.remove = s3c2410ts_remove,
.suspend = s3c2410ts_suspend,
.resume = s3c2410ts_resume,
};
static int __init s3c2410ts_init(void)
{
int rc;
rc = platform_driver_register(&s3c2410ts_driver);
if (rc < 0)
return rc;
rc = platform_driver_register(&s3c2440ts_driver);
if (rc < 0)
platform_driver_unregister(&s3c2410ts_driver);
return rc;
}
static void __exit s3c2410ts_exit(void)
{
platform_driver_unregister(&s3c2440ts_driver);
platform_driver_unregister(&s3c2410ts_driver);
}
module_init(s3c2410ts_init);
module_exit(s3c2410ts_exit);

183
target/linux/s3c24xx/files-2.6.30/drivers/input/touchscreen/ts_filter_chain.c Normal file
View File

@@ -0,0 +1,183 @@
/*
* 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 program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Copyright (c) 2008,2009 Andy Green <andy@openmoko.com>
*/
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/touchscreen/ts_filter_chain.h>
#include <linux/touchscreen/ts_filter.h>
/*
* Tux, would you like the following function in /lib?
* It helps us avoid silly code.
*/
/**
* sptrlen - Count how many non-null pointers are in a pointer array
* @arr: The array of pointers
*/
static int sptrlen(const void *arr)
{
/* All pointers have the same size. */
const int **p = (const int **)arr;
int len = 0;
while (*(p++))
len++;
return len;
}
struct ts_filter_chain {
/* All of the filters. */
struct ts_filter **arr;
/* Filters that can propagate values in the chain. */
struct ts_filter **pchain;
/* Length of the pchain array. */
int pchain_len;
/* FIXME: Add a spinlock and use it. */
};
struct ts_filter_chain *ts_filter_chain_create(
struct platform_device *pdev,
const struct ts_filter_chain_configuration conf[],
int count_coords)
{
struct ts_filter_chain *c;
int count = 0;
int len;
BUG_ON((count_coords < 1));
BUG_ON(count_coords > MAX_TS_FILTER_COORDS);
c = kzalloc(sizeof(struct ts_filter_chain), GFP_KERNEL);
if (!c)
goto create_err_1;
len = (sptrlen(conf) + 1);
/* Memory for two null-terminated arrays of filters. */
c->arr = kzalloc(2 * sizeof(struct ts_filter *) * len, GFP_KERNEL);
if (!c->arr)
goto create_err_1;
c->pchain = c->arr + len;
while (conf->api) {
/* TODO: Can we get away with only sending pdev->dev? */
struct ts_filter *f =
(conf->api->create)(pdev, conf->config, count_coords);
if (!f) {
dev_info(&pdev->dev, "Filter %d creation failed\n",
count);
goto create_err_2;
}
f->api = conf->api;
c->arr[count++] = f;
if (f->api->haspoint && f->api->getpoint && f->api->process)
c->pchain[c->pchain_len++] = f;
conf++;
}
dev_info(&pdev->dev, "%d filter(s) initialized\n", count);
return c;
create_err_2:
ts_filter_chain_destroy(c); /* Also frees c. */
create_err_1:
dev_info(&pdev->dev, "Error in filter chain initialization\n");
/*
* FIXME: Individual filters have to return errors this way.
* We only have to forward the errors we find.
*/
return ERR_PTR(-ENOMEM);
}
EXPORT_SYMBOL_GPL(ts_filter_chain_create);
void ts_filter_chain_destroy(struct ts_filter_chain *c)
{
if (c->arr) {
struct ts_filter **a = c->arr;
while (*a) {
((*a)->api->destroy)(*a);
a++;
}
kfree(c->arr);
}
kfree(c);
}
EXPORT_SYMBOL_GPL(ts_filter_chain_destroy);
void ts_filter_chain_clear(struct ts_filter_chain *c)
{
struct ts_filter **a = c->arr;
while (*a) {
if ((*a)->api->clear)
((*a)->api->clear)(*a);
a++;
}
}
EXPORT_SYMBOL_GPL(ts_filter_chain_clear);
static void ts_filter_chain_scale(struct ts_filter_chain *c, int *coords)
{
struct ts_filter **a = c->arr;
while (*a) {
if ((*a)->api->scale)
((*a)->api->scale)(*a, coords);
a++;
}
}
int ts_filter_chain_feed(struct ts_filter_chain *c, int *coords)
{
int len = c->pchain_len;
int i = len - 1;
if (!c->pchain[0])
return 1; /* Nothing to do. */
BUG_ON(c->pchain[0]->api->haspoint(c->pchain[0]));
if (c->pchain[0]->api->process(c->pchain[0], coords))
return -1;
while (i >= 0 && i < len) {
if (c->pchain[i]->api->haspoint(c->pchain[i])) {
c->pchain[i]->api->getpoint(c->pchain[i], coords);
if (++i < len &&
c->pchain[i]->api->process(c->pchain[i], coords))
return -1; /* Error. */
} else {
i--;
}
}
if (i >= 0) { /* Same as i == len. */
ts_filter_chain_scale(c, coords);
return 1;
}
return 0;
}
EXPORT_SYMBOL_GPL(ts_filter_chain_feed);

296
target/linux/s3c24xx/files-2.6.30/drivers/input/touchscreen/ts_filter_group.c Normal file
View File

@@ -0,0 +1,296 @@
/*
* 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 program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Copyright (C) 2008,2009 by Openmoko, Inc.
* Author: Nelson Castillo <arhuaco@freaks-unidos.net>
* All rights reserved.
*
*
* This filter is useful to reject samples that are not reliable. We consider
* that a sample is not reliable if it deviates form the Majority.
*
* 1) We collect S samples.
*
* 2) For each dimension:
*
* - We sort the points.
* - Points that are "close enough" are considered to be in the same set.
* - We choose the set with more elements. If more than "threshold"
* points are in this set we use the first and the last point of the set
* to define the valid range for this dimension [min, max], otherwise we
* discard all the points and go to step 1.
*
* 3) We consider the unsorted S samples and try to feed them to the next
* filter in the chain. If one of the points of each sample
* is not in the allowed range for its dimension, we discard the sample.
*
*/
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/sort.h>
#include <linux/touchscreen/ts_filter_group.h>
struct ts_filter_group {
/* Private filter configuration. */
struct ts_filter_group_configuration *config;
/* Filter API. */
struct ts_filter tsf;
int N; /* How many samples we have. */
int *samples[MAX_TS_FILTER_COORDS]; /* The samples: our input. */
int *group_size; /* Used for temporal computations. */
int *sorted_samples; /* Used for temporal computations. */
int range_max[MAX_TS_FILTER_COORDS]; /* Max. computed ranges. */
int range_min[MAX_TS_FILTER_COORDS]; /* Min. computed ranges. */
int tries_left; /* We finish if we don't get enough samples. */
int ready; /* If we are ready to deliver samples. */
int result; /* Index of the point being returned. */
};
#define ts_filter_to_filter_group(f) \
container_of(f, struct ts_filter_group, tsf)
static void ts_filter_group_clear_internal(struct ts_filter_group *tsfg,
int attempts)
{
tsfg->N = 0;
tsfg->tries_left = attempts;
tsfg->ready = 0;
tsfg->result = 0;
}
static void ts_filter_group_clear(struct ts_filter *tsf)
{
struct ts_filter_group *tsfg = ts_filter_to_filter_group(tsf);
ts_filter_group_clear_internal(tsfg, tsfg->config->attempts);
}
static struct ts_filter *ts_filter_group_create(
struct platform_device *pdev,
const struct ts_filter_configuration *conf,
int count_coords)
{
struct ts_filter_group *tsfg;
int i;
tsfg = kzalloc(sizeof(struct ts_filter_group), GFP_KERNEL);
if (!tsfg)
return NULL;
tsfg->config = container_of(conf,
struct ts_filter_group_configuration,
config);
tsfg->tsf.count_coords = count_coords;
BUG_ON(tsfg->config->attempts <= 0);
tsfg->samples[0] = kmalloc((2 + count_coords) * sizeof(int) *
tsfg->config->length, GFP_KERNEL);
if (!tsfg->samples[0]) {
kfree(tsfg);
return NULL;
}
for (i = 1; i < count_coords; ++i)
tsfg->samples[i] = tsfg->samples[0] + i * tsfg->config->length;
tsfg->sorted_samples = tsfg->samples[0] + count_coords *
tsfg->config->length;
tsfg->group_size = tsfg->samples[0] + (1 + count_coords) *
tsfg->config->length;
ts_filter_group_clear_internal(tsfg, tsfg->config->attempts);
dev_info(&pdev->dev, "Created Group filter len:%d coords:%d close:%d "
"thresh:%d\n", tsfg->config->length, count_coords,
tsfg->config->close_enough, tsfg->config->threshold);
return &tsfg->tsf;
}
static void ts_filter_group_destroy(struct ts_filter *tsf)
{
struct ts_filter_group *tsfg = ts_filter_to_filter_group(tsf);
kfree(tsfg->samples[0]); /* first guy has pointer from kmalloc */
kfree(tsf);
}
static int int_cmp(const void *_a, const void *_b)
{
const int *a = _a;
const int *b = _b;
if (*a > *b)
return 1;
if (*a < *b)
return -1;
return 0;
}
static void ts_filter_group_prepare_next(struct ts_filter *tsf);
static int ts_filter_group_process(struct ts_filter *tsf, int *coords)
{
struct ts_filter_group *tsfg = ts_filter_to_filter_group(tsf);
int n;
int i;
BUG_ON(tsfg->N >= tsfg->config->length);
BUG_ON(tsfg->ready);
for (n = 0; n < tsf->count_coords; n++)
tsfg->samples[n][tsfg->N] = coords[n];
if (++tsfg->N < tsfg->config->length)
return 0; /* We need more samples. */
for (n = 0; n < tsfg->tsf.count_coords; n++) {
int *v = tsfg->sorted_samples;
int ngroups = 0;
int best_size;
int best_idx = 0;
int idx = 0;
memcpy(v, tsfg->samples[n], tsfg->N * sizeof(int));
/*
* FIXME: Remove this sort call. We already have the
* algorithm for this modification. The filter will
* need less points (about half) if there is not a
* lot of noise. Right now we are doing a constant
* amount of work no matter how much noise we are
* dealing with.
*/
sort(v, tsfg->N, sizeof(int), int_cmp, NULL);
tsfg->group_size[0] = 1;
for (i = 1; i < tsfg->N; ++i) {
if (v[i] - v[i - 1] <= tsfg->config->close_enough)
tsfg->group_size[ngroups]++;
else
tsfg->group_size[++ngroups] = 1;
}
ngroups++;
best_size = tsfg->group_size[0];
for (i = 1; i < ngroups; i++) {
idx += tsfg->group_size[i - 1];
if (best_size < tsfg->group_size[i]) {
best_size = tsfg->group_size[i];
best_idx = idx;
}
}
if (best_size < tsfg->config->threshold) {
/* This set is not good enough for us. */
if (--tsfg->tries_left) {
ts_filter_group_clear_internal
(tsfg, tsfg->tries_left);
/* No errors but we need more samples. */
return 0;
}
return 1; /* We give up: error. */
}
tsfg->range_min[n] = v[best_idx];
tsfg->range_max[n] = v[best_idx + best_size - 1];
}
ts_filter_group_prepare_next(tsf);
return 0;
}
/*
* This private function prepares a point that will be returned
* in ts_filter_group_getpoint if it is available. It updates
* the priv->ready state also.
*/
static void ts_filter_group_prepare_next(struct ts_filter *tsf)
{
struct ts_filter_group *priv = ts_filter_to_filter_group(tsf);
int n;
while (priv->result < priv->N) {
for (n = 0; n < priv->tsf.count_coords; ++n) {
if (priv->samples[n][priv->result] <
priv->range_min[n] ||
priv->samples[n][priv->result] > priv->range_max[n])
break;
}
if (n == priv->tsf.count_coords) /* Sample is OK. */
break;
priv->result++;
}
if (unlikely(priv->result >= priv->N)) { /* No sample to deliver. */
ts_filter_group_clear_internal(priv, priv->config->attempts);
priv->ready = 0;
} else {
priv->ready = 1;
}
}
static int ts_filter_group_haspoint(struct ts_filter *tsf)
{
struct ts_filter_group *priv = ts_filter_to_filter_group(tsf);
return priv->ready;
}
static void ts_filter_group_getpoint(struct ts_filter *tsf, int *point)
{
struct ts_filter_group *priv = ts_filter_to_filter_group(tsf);
int n;
BUG_ON(!priv->ready);
for (n = 0; n < priv->tsf.count_coords; n++)
point[n] = priv->samples[n][priv->result];
priv->result++;
/* This call will update priv->ready. */
ts_filter_group_prepare_next(tsf);
}
/*
* Get ready to process the next batch of points, forget
* points we could have delivered.
*/
static void ts_filter_group_scale(struct ts_filter *tsf, int *coords)
{
struct ts_filter_group *priv = ts_filter_to_filter_group(tsf);
ts_filter_group_clear_internal(priv, priv->config->attempts);
}
const struct ts_filter_api ts_filter_group_api = {
.create = ts_filter_group_create,
.destroy = ts_filter_group_destroy,
.clear = ts_filter_group_clear,
.process = ts_filter_group_process,
.haspoint = ts_filter_group_haspoint,
.getpoint = ts_filter_group_getpoint,
.scale = ts_filter_group_scale,
};
EXPORT_SYMBOL_GPL(ts_filter_group_api);

212
target/linux/s3c24xx/files-2.6.30/drivers/input/touchscreen/ts_filter_linear.c Normal file
View File

@@ -0,0 +1,212 @@
/*
* 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 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Copyright (C) 2008,2009 by Openmoko, Inc.
* Author: Nelson Castillo <arhuaco@freaks-unidos.net>
* All rights reserved.
*
* Linearly scale touchscreen values.
*
* Expose the TS_FILTER_LINEAR_NCONSTANTS for the linear transformation
* using sysfs.
*
*/
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/touchscreen/ts_filter_linear.h>
struct ts_filter_linear;
/* Sysfs code. */
struct const_obj {
/* The actual private object. */
struct ts_filter_linear *tsfl;
/* Our kobject. */
struct kobject kobj;
};
#define to_const_obj(x) container_of(x, struct const_obj, kobj)
struct const_attribute {
struct attribute attr;
ssize_t (*show)(struct const_obj *const, struct const_attribute *attr,
char *buf);
ssize_t (*store)(struct const_obj *const, struct const_attribute *attr,
const char *buf, size_t count);
};
#define to_const_attr(x) container_of(x, struct const_attribute, attr)
/* Private linear filter structure. */
struct ts_filter_linear {
/* Private configuration for this filter. */
struct ts_filter_linear_configuration *config;
/* Generic filter API. */
struct ts_filter tsf;
/* Linear constants for the transformation. */
int constants[TS_FILTER_LINEAR_NCONSTANTS];
/* Sysfs. */
/* Our const_object. */
struct const_obj c_obj;
/* Our type. We will stick operations to it. */
struct kobj_type const_ktype;
/* Attrs. of the virtual files. */
struct const_attribute kattrs[TS_FILTER_LINEAR_NCONSTANTS];
/* Default Attrs. Always NULL for us. */
struct attribute *attrs[TS_FILTER_LINEAR_NCONSTANTS + 1];
/* Storage for the name of the virtual files. */
char attr_names[TS_FILTER_LINEAR_NCONSTANTS][2];
};
#define ts_filter_to_filter_linear(f) \
container_of(f, struct ts_filter_linear, tsf)
/* Sysfs functions. */
static ssize_t const_attr_show(struct kobject *kobj,
struct attribute *attr,
char *buf)
{
struct const_attribute *a = to_const_attr(attr);
return a->show(to_const_obj(kobj), a, buf);
}
static ssize_t const_attr_store(struct kobject *kobj,
struct attribute *attr,
const char *buf, size_t len)
{
struct const_attribute *a = to_const_attr(attr);
return a->store(to_const_obj(kobj), a, buf, len);
}
static struct sysfs_ops const_sysfs_ops = {
.show = const_attr_show,
.store = const_attr_store,
};
static void const_release(struct kobject *kobj)
{
kfree(to_const_obj(kobj)->tsfl);
}
static ssize_t const_show(struct const_obj *obj, struct const_attribute *attr,
char *buf)
{
int who;
sscanf(attr->attr.name, "%d", &who);
return sprintf(buf, "%d\n", obj->tsfl->constants[who]);
}
static ssize_t const_store(struct const_obj *obj, struct const_attribute *attr,
const char *buf, size_t count)
{
int who;
sscanf(attr->attr.name, "%d", &who);
sscanf(buf, "%d", &obj->tsfl->constants[who]);
return count;
}
/* Filter functions. */
static struct ts_filter *ts_filter_linear_create(
struct platform_device *pdev,
const struct ts_filter_configuration *conf,
int count_coords)
{
struct ts_filter_linear *tsfl;
int i;
int ret;
tsfl = kzalloc(sizeof(struct ts_filter_linear), GFP_KERNEL);
if (!tsfl)
return NULL;
tsfl->config = container_of(conf,
struct ts_filter_linear_configuration,
config);
tsfl->tsf.count_coords = count_coords;
for (i = 0; i < TS_FILTER_LINEAR_NCONSTANTS; ++i) {
tsfl->constants[i] = tsfl->config->constants[i];
/* sysfs */
sprintf(tsfl->attr_names[i], "%d", i);
tsfl->kattrs[i].attr.name = tsfl->attr_names[i];
tsfl->kattrs[i].attr.mode = 0666;
tsfl->kattrs[i].show = const_show;
tsfl->kattrs[i].store = const_store;
tsfl->attrs[i] = &tsfl->kattrs[i].attr;
}
tsfl->attrs[i] = NULL;
tsfl->const_ktype.sysfs_ops = &const_sysfs_ops;
tsfl->const_ktype.release = const_release;
tsfl->const_ktype.default_attrs = tsfl->attrs;
tsfl->c_obj.tsfl = tsfl; /* kernel frees tsfl in const_release */
ret = kobject_init_and_add(&tsfl->c_obj.kobj, &tsfl->const_ktype,
&pdev->dev.kobj, "calibration");
if (ret) {
kobject_put(&tsfl->c_obj.kobj);
return NULL;
}
dev_info(&pdev->dev, "Created Linear filter coords:%d\n", count_coords);
return &tsfl->tsf;
}
static void ts_filter_linear_destroy(struct ts_filter *tsf)
{
struct ts_filter_linear *tsfl = ts_filter_to_filter_linear(tsf);
/* Kernel frees tsfl in const_release. */
kobject_put(&tsfl->c_obj.kobj);
}
static void ts_filter_linear_scale(struct ts_filter *tsf, int *coords)
{
struct ts_filter_linear *tsfl = ts_filter_to_filter_linear(tsf);
int *k = tsfl->constants;
int c0 = coords[tsfl->config->coord0];
int c1 = coords[tsfl->config->coord1];
coords[tsfl->config->coord0] = (k[2] + k[0] * c0 + k[1] * c1) / k[6];
coords[tsfl->config->coord1] = (k[5] + k[3] * c0 + k[4] * c1) / k[6];
}
const struct ts_filter_api ts_filter_linear_api = {
.create = ts_filter_linear_create,
.destroy = ts_filter_linear_destroy,
.scale = ts_filter_linear_scale,
};
EXPORT_SYMBOL_GPL(ts_filter_linear_api);

174
target/linux/s3c24xx/files-2.6.30/drivers/input/touchscreen/ts_filter_mean.c Normal file
View File

@@ -0,0 +1,174 @@
/*
* 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 program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Copyright (c) 2008,2009
* Andy Green <andy@openmoko.com>
* Nelson Castillo <arhuaco@freaks-unidos.net>
*
* Simple mean filter.
*
*/
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/touchscreen/ts_filter_mean.h>
struct ts_filter_mean {
/* Copy of the private filter configuration. */
struct ts_filter_mean_configuration *config;
/* Filter API. */
struct ts_filter tsf;
/* Index on a circular buffer. */
int curr;
/* Useful to tell if the circular buffer is full(read:ready). */
int count;
/* Sumation used to compute the mean. */
int sum[MAX_TS_FILTER_COORDS];
/* Keep point values and decrement them from the sum on time. */
int *fifo[MAX_TS_FILTER_COORDS];
/* Store the output of this filter. */
int ready;
};
#define ts_filter_to_filter_mean(f) container_of(f, struct ts_filter_mean, tsf)
static void ts_filter_mean_clear(struct ts_filter *tsf);
static struct ts_filter *ts_filter_mean_create(
struct platform_device *pdev,
const struct ts_filter_configuration *conf,
int count_coords)
{
struct ts_filter_mean *priv;
int *v;
int n;
priv = kzalloc(sizeof(struct ts_filter_mean), GFP_KERNEL);
if (!priv)
return NULL;
priv->tsf.count_coords = count_coords;
priv->config = container_of(conf,
struct ts_filter_mean_configuration,
config);
BUG_ON(priv->config->length <= 0);
v = kmalloc(priv->config->length * sizeof(int) * count_coords,
GFP_KERNEL);
if (!v)
return NULL;
for (n = 0; n < count_coords; n++) {
priv->fifo[n] = v;
v += priv->config->length;
}
ts_filter_mean_clear(&priv->tsf);
dev_info(&pdev->dev, "Created Mean filter len:%d coords:%d\n",
priv->config->length, count_coords);
return &priv->tsf;
}
static void ts_filter_mean_destroy(struct ts_filter *tsf)
{
struct ts_filter_mean *priv = ts_filter_to_filter_mean(tsf);
kfree(priv->fifo[0]); /* first guy has pointer from kmalloc */
kfree(tsf);
}
static void ts_filter_mean_clear(struct ts_filter *tsf)
{
struct ts_filter_mean *priv = ts_filter_to_filter_mean(tsf);
priv->count = 0;
priv->curr = 0;
priv->ready = 0;
memset(priv->sum, 0, tsf->count_coords * sizeof(int));
}
static int ts_filter_mean_process(struct ts_filter *tsf, int *coords)
{
struct ts_filter_mean *priv = ts_filter_to_filter_mean(tsf);
int n;
BUG_ON(priv->ready);
for (n = 0; n < tsf->count_coords; n++) {
priv->sum[n] += coords[n];
priv->fifo[n][priv->curr] = coords[n];
}
if (priv->count + 1 == priv->config->length)
priv->ready = 1;
else
priv->count++;
priv->curr = (priv->curr + 1) % priv->config->length;
return 0; /* No error. */
}
static int ts_filter_mean_haspoint(struct ts_filter *tsf)
{
struct ts_filter_mean *priv = ts_filter_to_filter_mean(tsf);
return priv->ready;
}
static void ts_filter_mean_getpoint(struct ts_filter *tsf, int *point)
{
struct ts_filter_mean *priv = ts_filter_to_filter_mean(tsf);
int n;
BUG_ON(!priv->ready);
for (n = 0; n < tsf->count_coords; n++) {
point[n] = priv->sum[n];
priv->sum[n] -= priv->fifo[n][priv->curr];
}
priv->ready = 0;
}
static void ts_filter_mean_scale(struct ts_filter *tsf, int *coords)
{
int n;
struct ts_filter_mean *priv = ts_filter_to_filter_mean(tsf);
for (n = 0; n < tsf->count_coords; n++) {
coords[n] += priv->config->length >> 1; /* Rounding. */
coords[n] /= priv->config->length;
}
}
const struct ts_filter_api ts_filter_mean_api = {
.create = ts_filter_mean_create,
.destroy = ts_filter_mean_destroy,
.clear = ts_filter_mean_clear,
.process = ts_filter_mean_process,
.scale = ts_filter_mean_scale,
.haspoint = ts_filter_mean_haspoint,
.getpoint = ts_filter_mean_getpoint,
};
EXPORT_SYMBOL_GPL(ts_filter_mean_api);

261
target/linux/s3c24xx/files-2.6.30/drivers/input/touchscreen/ts_filter_median.c Normal file
View File

@@ -0,0 +1,261 @@
/*
* 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 program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Copyright (c) 2008 Andy Green <andy@openmoko.com>
*
*
* Median averaging stuff. We sort incoming raw samples into an array of
* MEDIAN_SIZE length, discarding the oldest sample each time once we are full.
* We then return the sum of the middle three samples for X and Y. It means
* the final result must be divided by (3 * scaling factor) to correct for
* avoiding the repeated /3.
*
* This strongly rejects brief excursions away from a central point that is
* sticky in time compared to the excursion duration.
*
* Thanks to Dale Schumacher (who wrote some example code) and Carl-Daniel
* Halifinger who pointed out this would be a good method.
*/
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/touchscreen/ts_filter_median.h>
struct ts_filter_median {
/* Private configuration. */
struct ts_filter_median_configuration *config;
/* Generic Filter API. */
struct ts_filter tsf;
/* Count raw samples we get. */
int samples_count;
/*
* Remember the last coordinates we got in order to know if
* we are moving slow or fast.
*/
int last_issued[MAX_TS_FILTER_COORDS];
/* How many samples in the sort buffer are valid. */
int valid;
/* Samples taken for median in sorted form. */
int *sort[MAX_TS_FILTER_COORDS];
/* Samples taken for median. */
int *fifo[MAX_TS_FILTER_COORDS];
/* Where we are in the fifo sample memory. */
int pos;
/* Do we have a sample to deliver? */
int ready;
};
#define ts_filter_to_filter_median(f) \
container_of(f, struct ts_filter_median, tsf)
static void ts_filter_median_insert(int *p, int sample, int count)
{
int n;
/* Search through what we got so far to find where to put sample. */
for (n = 0; n < count; n++)
if (sample < p[n]) { /* We met somebody bigger than us? */
/* Starting from the end, push bigger guys down one. */
for (count--; count >= n; count--)
p[count + 1] = p[count];
p[n] = sample; /* Put us in place of first bigger. */
return;
}
p[count] = sample; /* Nobody was bigger than us, add us on the end. */
}
static void ts_filter_median_del(int *p, int value, int count)
{
int index;
for (index = 0; index < count; index++)
if (p[index] == value) {
for (; index < count; index++)
p[index] = p[index + 1];
return;
}
}
static void ts_filter_median_clear(struct ts_filter *tsf)
{
struct ts_filter_median *tsfm = ts_filter_to_filter_median(tsf);
tsfm->pos = 0;
tsfm->valid = 0;
tsfm->ready = 0;
memset(&tsfm->last_issued[0], 1, tsf->count_coords * sizeof(int));
}
static struct ts_filter *ts_filter_median_create(
struct platform_device *pdev,
const struct ts_filter_configuration *conf,
int count_coords)
{
int *p;
int n;
struct ts_filter_median *tsfm = kzalloc(sizeof(struct ts_filter_median),
GFP_KERNEL);
if (!tsfm)
return NULL;
tsfm->config = container_of(conf,
struct ts_filter_median_configuration,
config);
tsfm->tsf.count_coords = count_coords;
tsfm->config->midpoint = (tsfm->config->extent >> 1) + 1;
p = kmalloc(2 * count_coords * sizeof(int) * (tsfm->config->extent + 1),
GFP_KERNEL);
if (!p) {
kfree(tsfm);
return NULL;
}
for (n = 0; n < count_coords; n++) {
tsfm->sort[n] = p;
p += tsfm->config->extent + 1;
tsfm->fifo[n] = p;
p += tsfm->config->extent + 1;
}
ts_filter_median_clear(&tsfm->tsf);
dev_info(&pdev->dev,
"Created Median filter len:%d coords:%d dec_threshold:%d\n",
tsfm->config->extent, count_coords,
tsfm->config->decimation_threshold);
return &tsfm->tsf;
}
static void ts_filter_median_destroy(struct ts_filter *tsf)
{
struct ts_filter_median *tsfm = ts_filter_to_filter_median(tsf);
kfree(tsfm->sort[0]); /* First guy has pointer from kmalloc. */
kfree(tsf);
}
static void ts_filter_median_scale(struct ts_filter *tsf, int *coords)
{
int n;
for (n = 0; n < tsf->count_coords; n++)
coords[n] = (coords[n] + 2) / 3;
}
/*
* Give us the raw sample data coords, and if we return 1 then you can
* get a filtered coordinate from coords. If we return 0 you didn't
* fill all the filters with samples yet.
*/
static int ts_filter_median_process(struct ts_filter *tsf, int *coords)
{
struct ts_filter_median *tsfm = ts_filter_to_filter_median(tsf);
int n;
int movement = 1;
for (n = 0; n < tsf->count_coords; n++) {
/* Grab copy in insertion order to remove when oldest. */
tsfm->fifo[n][tsfm->pos] = coords[n];
/* Insert these samples in sorted order in the median arrays. */
ts_filter_median_insert(tsfm->sort[n], coords[n], tsfm->valid);
}
/* Move us on in the fifo. */
if (++tsfm->pos == (tsfm->config->extent + 1))
tsfm->pos = 0;
/* Have we finished a median sampling? */
if (++tsfm->valid < tsfm->config->extent)
goto process_exit; /* No valid sample to use. */
BUG_ON(tsfm->valid != tsfm->config->extent);
tsfm->valid--;
/*
* Sum the middle 3 in the median sorted arrays. We don't divide back
* down which increases the sum resolution by a factor of 3 until the
* scale API function is called.
*/
for (n = 0; n < tsf->count_coords; n++)
/* Perform the deletion of the oldest sample. */
ts_filter_median_del(tsfm->sort[n], tsfm->fifo[n][tsfm->pos],
tsfm->valid);
tsfm->samples_count--;
if (tsfm->samples_count >= 0)
goto process_exit;
for (n = 0; n < tsf->count_coords; n++) {
/* Give the coordinate result from summing median 3. */
coords[n] = tsfm->sort[n][tsfm->config->midpoint - 1] +
tsfm->sort[n][tsfm->config->midpoint] +
tsfm->sort[n][tsfm->config->midpoint + 1];
movement += abs(tsfm->last_issued[n] - coords[n]);
}
if (movement > tsfm->config->decimation_threshold) /* Moving fast. */
tsfm->samples_count = tsfm->config->decimation_above;
else
tsfm->samples_count = tsfm->config->decimation_below;
memcpy(&tsfm->last_issued[0], coords, tsf->count_coords * sizeof(int));
tsfm->ready = 1;
process_exit:
return 0;
}
static int ts_filter_median_haspoint(struct ts_filter *tsf)
{
struct ts_filter_median *priv = ts_filter_to_filter_median(tsf);
return priv->ready;
}
static void ts_filter_median_getpoint(struct ts_filter *tsf, int *point)
{
struct ts_filter_median *priv = ts_filter_to_filter_median(tsf);
BUG_ON(!priv->ready);
memcpy(point, &priv->last_issued[0], tsf->count_coords * sizeof(int));
priv->ready = 0;
}
const struct ts_filter_api ts_filter_median_api = {
.create = ts_filter_median_create,
.destroy = ts_filter_median_destroy,
.clear = ts_filter_median_clear,
.process = ts_filter_median_process,
.scale = ts_filter_median_scale,
.haspoint = ts_filter_median_haspoint,
.getpoint = ts_filter_median_getpoint,
};
EXPORT_SYMBOL_GPL(ts_filter_median_api);