JZ2440上的触摸屏驱动优化简述

直接上源代码：

#include <linux/input.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/clk.h>
#include <linux/jiffies.h>

#include <asm/io.h>
#include <asm/delay.h>
#include <asm/arch/regs-adc.h>
#include <asm/irq.h>
#include <asm/arch/regs-irq.h>

//#define DEBUG_TS

#define TCMODNAME     "ts_touch"
#define ADCMODNAME    "ts_adc"

#define S3C2440_TS_ABS_X_MIN    0
#define S3C2440_TS_ABS_X_MAX    0x3ff
#define S3C2440_TS_ABS_Y_MIN    0
#define S3C2440_TS_ABS_Y_MAX    0x3ff

#define PEN_DOWN (0 << 8)
#define PEN_UP (1 << 8)

//进入等待中断模式，等待触摸屏被按下
#define WAIT_DOWN_INT() { \
                            writel(PEN_DOWN | \
                            S3C2410_ADCTSC_YM_SEN | \
                            S3C2410_ADCTSC_YP_SEN | \
                            S3C2410_ADCTSC_XP_SEN | \
                            S3C2410_ADCTSC_XY_PST(3), S3C2410_ADCTSC); \
                        }

//进入等待中断模式，等待触摸屏被按下
#define WAIT_UP_INT() { \
                            writel(PEN_UP | \
                            S3C2410_ADCTSC_YM_SEN | \
                            S3C2410_ADCTSC_YP_SEN | \
                            S3C2410_ADCTSC_XP_SEN | \
                            S3C2410_ADCTSC_XY_PST(3), S3C2410_ADCTSC); \
                        }

//使能ADC转换
#define ENABLE_START()    { \
                            writel( \
                            readl(S3C2410_ADCCON) | \
                            S3C2410_ADCCON_ENABLE_START , \
                            S3C2410_ADCCON); \
                        }

//进入自动X/Y坐标转换模式
#define AUTO_PST_INT() { \
                            writel( \
                            S3C2410_ADCTSC_PULL_UP_DISABLE | \
                            S3C2410_ADCTSC_AUTO_PST | \
                            S3C2410_ADCTSC_XY_PST(0), S3C2410_ADCTSC); \
                            ENABLE_START(); \
                        }

//定义每个触摸点采样的次数
#define CVR_CNT    6 //必须大于3，因为会去掉最大和最小值

struct s3c24xx_ts_dev {
    struct input_dev *dev;
    struct clk *clk;
    unsigned int cnt; //for adc
    int px[CVR_CNT];
    int py[CVR_CNT];
    int old_px;
    int old_py;
    unsigned int oflag; //for ts
};
static struct s3c24xx_ts_dev *ts_devp;

//定义一个延时队列，将坐标相关工作移到中断下半部完成
static void do_adc_convert(struct work_struct *work);
static DECLARE_DELAYED_WORK(ts_work, do_adc_convert);


//检测是否是按下模式
static unsigned int get_down_status(void)
{
    return !((readl(S3C2410_ADCDAT0) & S3C2410_ADCDAT0_UPDOWN) >> 15) &&
                !((readl(S3C2410_ADCDAT1) & S3C2410_ADCDAT1_UPDOWN) >> 15); //通过读取ADCDATX的第15位，等到相关信息
}

//计算平均值，并将最小和最大的两个数据丢弃
static int get_truth_value(int *dat, unsigned int cnt)
{
    int tmp_min, tmp_max, tmp_val, tmp_sum = 0;
    unsigned int i;

    tmp_min = tmp_max = tmp_sum = dat[0];

    for (i = 1; i < cnt-1; i++) {
        if(tmp_min > dat[i])
            tmp_min = dat[i];
        if(tmp_max < dat[i])
            tmp_max = dat[i];
        tmp_sum += dat[i];
    }

    tmp_val = (tmp_sum - tmp_min - tmp_max) / (cnt - 2);

    return tmp_val;
}

static int is_big_deviation(int new_x, int new_y, int old_x, int old_y)
{
    int tmp_x = new_x - old_x;
    int tmp_y = new_y - old_y;

    if ((tmp_x < -3 || tmp_x > 3) ||
            (tmp_y < -3 || tmp_y > 3))
        return 1;

    else
        return 0;
}

//获取ADC转换数据，进行累加，平均，之后提交输入事件。
static void do_adc_convert(struct work_struct *work)
{
    int absx = 0, absy = 0;

    if (get_down_status()) {    //按下状态，读取X轴和Y轴数据。
        absy = (readl(S3C2410_ADCDAT0) & S3C2410_ADCDAT0_XPDATA_MASK);     //发现对应的X和Y轴颠倒，故修正
        absx = (readl(S3C2410_ADCDAT1) & S3C2410_ADCDAT1_YPDATA_MASK);

        if (1 == ts_devp->oflag) {
            if (!is_big_deviation(absx, absy, ts_devp->old_px, ts_devp->old_py)) {
                ts_devp->oflag = 0; //清除两次采样标记

                ts_devp->px[ts_devp->cnt] = absx; //累加相应坐标的数据，并累加次数
                ts_devp->py[ts_devp->cnt] = absy;
                ts_devp->cnt++;

                if (ts_devp->cnt >= CVR_CNT) {
                    WAIT_UP_INT(); //进入等待释放模式

                    absx = get_truth_value(ts_devp->px, ts_devp->cnt);
                    absy = get_truth_value(ts_devp->py, ts_devp->cnt);
                    ts_devp->cnt = 0;

                    msleep(6); //必须等待，保证松开的中断被触发，此值需要根据ADCDLY寄存器进行调整

                    if (get_down_status()) {
                        input_report_key(ts_devp->dev, BTN_TOUCH, 1); //向输入核心层提交相关数据
                        input_report_abs(ts_devp->dev, ABS_X, absx);
                        input_report_abs(ts_devp->dev, ABS_Y, absy);
                        input_report_abs(ts_devp->dev, ABS_PRESSURE, 1);
                        input_sync(ts_devp->dev);

                        schedule_delayed_work(&ts_work, 0); //在前面调用了msleep(),所以再此处直接运行。
                    }
                } else {
                    AUTO_PST_INT(); //必须再次设置自动转换并使能ADC，否则S3C2410_ADCDAT0的值有问题
                }

            } else {
                ts_devp->oflag = 0;
                AUTO_PST_INT(); //必须再次设置自动转换并使能ADC，否则S3C2410_ADCDAT0的值有问题
            }
        } else {
            ts_devp->oflag = 1;
            ts_devp->old_px = absx;
            ts_devp->old_py = absy;

            AUTO_PST_INT(); //必须再次设置自动转换并使能ADC，否则S3C2410_ADCDAT0的值有问题
        }
    } else {
        input_report_key(ts_devp->dev, BTN_TOUCH, 0);
        input_report_abs(ts_devp->dev, ABS_PRESSURE, 0);
        input_sync(ts_devp->dev);

        ts_devp->cnt = 0;
        ts_devp->oflag = 0;

        WAIT_DOWN_INT();
    }
}

//初始化相应的ADC寄存器，设置分频，并进入等待按下模式
static int init_s3c24xx_adcreg(void)
{
    unsigned long reg_tmp;

    reg_tmp = S3C2410_ADCCON_PRSCEN |         // prescaler enable
              S3C2410_ADCCON_PRSCVL(24);        // PCLK=50MHz, AD_CLK<=2.5MHz, AD_CLK = PCLK / (PRSCVL + 1)
    writel(reg_tmp, S3C2410_ADCCON);

    writel(6000, S3C2410_ADCDLY); //在触摸按下和ADC转换之间，需要延时，否则极易出现不稳定的情况。

    WAIT_DOWN_INT(); //自动等待模式(按下)
}

//发生INC_TC中断时，会进入此函数
static irqreturn_t ts_touch_interrupt(int irq, void *dev_id)
{
    if (get_down_status()) {
        AUTO_PST_INT();

    } else {
        input_report_key(ts_devp->dev, BTN_TOUCH, 0);
        input_report_abs(ts_devp->dev, ABS_PRESSURE, 0);
        input_sync(ts_devp->dev);

        ts_devp->cnt = 0;
        ts_devp->oflag = 0;

        WAIT_DOWN_INT();
    }
    return IRQ_HANDLED;
}

//发生INC_ADC中断时，会进入此函数
static irqreturn_t ts_adc_interrupt(int irq, void *dev_id)
{
    schedule_delayed_work(&ts_work, 0); //立即启动ts_work队列，调用do_adc_convert()

    return IRQ_HANDLED;
}


/*
 * The functions for inserting/removing us as a module.
 */

static int __init s3c24xx_ts_init(void)
{
    int err;

    ts_devp = kzalloc(sizeof(struct s3c24xx_ts_dev), GFP_KERNEL);
    if (!ts_devp)
        return -ENOMEM;

    ts_devp->clk = clk_get(NULL, "adc");
    clk_enable(ts_devp->clk);

    ts_devp->dev = input_allocate_device();
    if (!ts_devp->dev)
        return -ENOMEM;

    ts_devp->dev->name = "s3c24xx_touchscreen";
    ts_devp->dev->phys = "s3c24xx/input0";
    ts_devp->dev->id.bustype = BUS_RS232;
    ts_devp->dev->id.vendor = 0xdead;
    ts_devp->dev->id.product = 0xbeef;
    ts_devp->dev->id.version = 0x0101;

    ts_devp->cnt = 0;
    ts_devp->oflag = 0;

    ts_devp->dev->evbit[0] = BIT(EV_ABS) | BIT(EV_KEY);
    ts_devp->dev->keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);

    input_set_abs_params(ts_devp->dev, ABS_X,
        S3C2440_TS_ABS_X_MIN, S3C2440_TS_ABS_X_MAX, 0, 0);
    input_set_abs_params(ts_devp->dev, ABS_Y,
        S3C2440_TS_ABS_Y_MIN, S3C2440_TS_ABS_Y_MAX, 0, 0);
    input_set_abs_params(ts_devp->dev, ABS_PRESSURE,
        0, 1, 0, 0);

    if (request_irq(IRQ_TC, ts_touch_interrupt ,
            IRQF_DISABLED, TCMODNAME, NULL) < 0) {
        printk(KERN_ERR "s3c24xx_ts_input.c: Can't allocate irq %d\n",
               IRQ_TC);
        err = -EBUSY;
        goto fail1;
    }

    if (request_irq(IRQ_ADC, ts_adc_interrupt,
            IRQF_DISABLED, ADCMODNAME, NULL) < 0) {
        printk(KERN_ERR "s3c24xx_ts_input.c: Can't allocate irq %d\n",
               IRQ_ADC);
        err = -EBUSY;
        goto fail2;
    }

    err = input_register_device(ts_devp->dev);
    if (err)
        goto fail3;

    init_s3c24xx_adcreg();

    return 0;

fail3:
    free_irq(IRQ_ADC, NULL);

fail2:
    free_irq(IRQ_TC, NULL);
    cancel_delayed_work(&ts_work);
    flush_scheduled_work();

fail1:
    input_free_device(ts_devp->dev);
    return err;
}

static void __exit s3c24xx_ts_exit(void)
{
    input_unregister_device(ts_devp->dev);

    free_irq(IRQ_ADC, NULL);
    free_irq(IRQ_TC, NULL);

    cancel_delayed_work(&ts_work);
    flush_scheduled_work();

    input_free_device(ts_devp->dev);

    kfree(ts_devp);
}

module_init(s3c24xx_ts_init);
module_exit(s3c24xx_ts_exit);

软件在处理跳点时加入了一些处理方法，与上一版有些不同，软件简单测试，工作良好，不过应该还有改进的空间。

这个软件调试花了我2天的时间，周末基本都在弄这个，开发的难点如下：
1、如何去除跳点，于是就采用了采样两点后进行比较，如果误差较大，则废弃这两个坐标。总共采样6次，在6个样本中去掉最大和最小值后取平均值。
2、最后在最后松开时，发生跳点，而之前的所有坐标都OK。我就想是不是松开后相应的中断无法触发（因为一直在自动转换模式中），于是就进行了相应的处理。 --- 想明白这个问题花了近一天的时间，效率低啊~~~
3、有时候底层去处理一些数据还是比较麻烦的，比如在松开时跳点问题，在上层软件中可以直接进行滤除操作。

关于松开时发生跳点的问题，我想在这里再说下。
1、处于自动转换模式时，松开的动作是无法触发中断的。
2、因为已经松开，所以ADC采样的是悬空状态的电压（未知电压）。
3、必须在提交坐标信息到输入子系统之前明确是否是松开状态。

最后有图有真相~~     这是基于TSLIB，优化触摸屏驱动后的~~