S3C2440上触摸屏驱动实例开发讲解

一、开发环境

• 主  机：VMWare--Fedora 9
• 开发板：Mini2440--64MB Nand, Kernel:2.6.30.4
• 编译器：arm-linux-gcc-4.3.2

二、前提知识

1、Linux输入子系统(Input Subsystem)：

   在Linux中，输入子系统是由输入子系统设备驱动层、输入子系统核心层(Input Core)和输入子系统事件处理层(Event Handler)组成。其中设备驱动层提供对硬件各寄存器的读写访问和将底层硬件对用户输入访问的响应转换为标准的输入事件，再通过核心层提交给事件处理层；而核心层对下提供了设备驱动层的编程接口，对上又提供了事件处理层的编程接口；而事件处理层就为我们用户空间的应用程序提供了统一访问设备的接口和驱动层提交来的事件处理。所以这使得我们输入设备的驱动部分不在用关心对设备文件的操作，而是要关心对各硬件寄存器的操作和提交的输入事件。下面用图形来描述一下这三者的关系吧！

另外，又找了另一幅图来说明Linux输入子系统的结构，可能更加形象容易理解。如下：

2、输入子系统设备驱动层实现原理：

   在Linux中，Input设备用input_dev结构体描述，定义在input.h中。设备的驱动只需按照如下步骤就可实现了。
①、在驱动模块加载函数中设置Input设备支持input子系统的哪些事件；
②、将Input设备注册到input子系统中；
③、在Input设备发生输入操作时(如：键盘被按下/抬起、触摸屏被触摸/抬起/移动、鼠标被移动/单击/抬起时等)，提交所发生的事件及对应的键值/坐标等状态。

Linux中输入设备的事件类型有(这里只列出了常用的一些，更多请看linux/input.h中)：

EV_SYN     0x00     同步事件
EV_KEY     0x01     按键事件
EV_REL     0x02     相对坐标(如：鼠标移动，报告的是相对最后一次位置的偏移)
EV_ABS     0x03     绝对坐标(如：触摸屏和操作杆，报告的是绝对的坐标位置)
EV_MSC     0x04     其它
EV_LED     0x11     LED
EV_SND     0x12     声音
EV_REP     0x14     Repeat
EV_FF      0x15     力反馈

用于提交较常用的事件类型给输入子系统的函数有：

void input_report_key(struct input_dev *dev, unsigned int code, int value); //提交按键事件的函数
void input_report_rel(struct input_dev *dev, unsigned int code, int value); //提交相对坐标事件的函数
void input_report_abs(struct input_dev *dev, unsigned int code, int value); //提交绝对坐标事件的函数

注意，在提交输入设备的事件后必须用下列方法使事件同步，让它告知input系统，设备驱动已经发出了一个完整的报告：

void input_sync(struct input_dev *dev)

三、触摸屏驱动的实现步骤

1、硬件原理图分析：

   S3c2440芯片内部触摸屏接口与ADC接口是集成在一起的，硬件结构原理图请看：S3C2440上ADC驱动实例开发讲解中的图，其中通道7(XP或AIN7)作为触摸屏接口的X坐标输入，通道5(YP或AIN5)作为触摸屏接口的Y坐标输入。在"S3C2440上ADC驱动实例开发讲解"中，AD转换的模拟信号是由开发板上的一个电位器产生并通过通道1(AIN0)输入的，而这里的模拟信号则是由点触触摸屏所产生的X坐标和Y坐标两个模拟信号，并分别通过通道7和通道5输入。S3c2440提供的触摸屏接口有4种处理模式，分别是：正常转换模式、单独的X/Y位置转换模式、自动X/Y位置转换模式和等待中断模式，对于在每种模式下工作的要求，请详细查看数据手册的描述。本驱动实例将采用自动X/Y位置转换模式和等待中断模式。

注意：在每步中，为了让代码逻辑更加有条理和容易理解，就没有考虑代码的顺序，比如函数要先定义后调用。如果要编译此代码，请严格按照C语言的规范来调整代码的顺序。

2、建立触摸屏驱动程序my2440_ts.c，首先实现加载和卸载部分，在驱动加载部分，我们主要做的事情是：启用ADC所需要的时钟、映射IO口、初始化寄存器、申请中断、初始化输入设备、将输入设备注册到输入子系统。代码如下：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/clk.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/serio.h>
#include <plat/regs-adc.h>
#include <asm/irq.h>
#include <asm/io.h>

 

/*用于保存从平台时钟列表中获取的ADC时钟*/
static struct clk *adc_clk;

/*定义了一个用来保存经过虚拟映射后的内存地址*/
static void __iomem *adc_base;

/*定义一个输入设备来表示我们的触摸屏设备*/
static struct input_dev *ts_dev;

/*设备名称*/
#define DEVICE_NAME    "my2440_TouchScreen"

/*定义一个WAIT4INT宏，该宏将对ADC触摸屏控制寄存器进行操作
S3C2410_ADCTSC_YM_SEN这些宏都定义在regs-adc.h中*/
#define WAIT4INT(x)    (((x)<<8) | S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | \
                    S3C2410_ADCTSC_XP_SEN | S3C2410_ADCTSC_XY_PST(3))

static int __init ts_init(void)
{
    int ret;

    /*从平台时钟队列中获取ADC的时钟，这里为什么要取得这个时钟，因为ADC的转换频率跟时钟有关。
    系统的一些时钟定义在arch/arm/plat-s3c24xx/s3c2410-clock.c中*/
    adc_clk = clk_get(NULL, "adc");
    if(!adc_clk)
    {
        /*错误处理*/
        printk(KERN_ERR "falied to find adc clock source\n");
        return -ENOENT;
    }

    /*时钟获取后要使能后才可以使用，clk_enable定义在arch/arm/plat-s3c/clock.c中*/
    clk_enable(adc_clk);

    /*将ADC的IO端口占用的这段IO空间映射到内存的虚拟地址，ioremap定义在io.h中。
     注意：IO空间要映射后才能使用，以后对虚拟地址的操作就是对IO空间的操作,
     S3C2410_PA_ADC是ADC控制器的基地址，定义在mach-s3c2410/include/mach/map.h中，0x20是虚拟地址长度大小*/
    adc_base = ioremap(S3C2410_PA_ADC, 0x20);
    if(adc_base == NULL)
    {
        /*错误处理*/
        printk(KERN_ERR "failed to remap register block\n");
        ret = -EINVAL;
        goto err_noclk;
    }

    /*初始化ADC控制寄存器和ADC触摸屏控制寄存器*/
    adc_initialize();

    /*申请ADC中断，AD转换完成后触发。这里使用共享中断IRQF_SHARED是因为该中断号在ADC驱动中也使用了，
    最后一个参数1是随便给的一个值，因为如果不给值设为NULL的话，中断就申请不成功*/
    ret = request_irq(IRQ_ADC, adc_irq, IRQF_SHARED | IRQF_SAMPLE_RANDOM, DEVICE_NAME, 1);
    if(ret)
    {
        printk(KERN_ERR "IRQ%d error %d\n", IRQ_ADC, ret);
        ret = -EINVAL;
        goto err_nomap;
    }

    /*申请触摸屏中断，对触摸屏按下或提笔时触发*/
    ret = request_irq(IRQ_TC, tc_irq, IRQF_SAMPLE_RANDOM, DEVICE_NAME, 1);
    if(ret)
    {
        printk(KERN_ERR "IRQ%d error %d\n", IRQ_TC, ret);
        ret = -EINVAL;
        goto err_noirq;
    }

    /*给输入设备申请空间，input_allocate_device定义在input.h中*/
    ts_dev = input_allocate_device();

    /*下面初始化输入设备，即给输入设备结构体input_dev的成员设置值。
    evbit字段用于描述支持的事件，这里支持同步事件、按键事件、绝对坐标事件，
    BIT宏实际就是对1进行位操作，定义在linux/bitops.h中*/
    ts_dev->evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS);
    
    /*keybit字段用于描述按键的类型，在input.h中定义了很多，这里用BTN_TOUCH类型来表示触摸屏的点击*/
    ts_dev->keybit[BITS_TO_LONGS(BTN_TOUCH)] = BIT(BTN_TOUCH);

    /*对于触摸屏来说，使用的是绝对坐标系统。这里设置该坐标系统中X和Y坐标的最小值和最大值(0-1023范围)
    ABS_X和ABS_Y就表示X坐标和Y坐标，ABS_PRESSURE就表示触摸屏是按下还是抬起状态*/
    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);

    /*以下是设置触摸屏输入设备的身份信息，直接在这里写死。
    这些信息可以在驱动挂载后在/proc/bus/input/devices中查看到*/
    ts_dev->name          = DEVICE_NAME;   /*设备名称*/
    ts_dev->id.bustype    = BUS_RS232;     /*总线类型*/    
    ts_dev->id.vendor     = 0xDEAD;        /*经销商ID号*/
    ts_dev->id.product    = 0xBEEF;        /*产品ID号*/
    ts_dev->id.version    = 0x0101;        /*版本ID号*/

    /*好了，一些都准备就绪，现在就把ts_dev触摸屏设备注册到输入子系统中*/
    input_register_device(ts_dev);

    return 0;

/*下面是错误跳转处理*/
err_noclk:
    clk_disable(adc_clk);
    clk_put(adc_clk);

err_nomap:
    iounmap(adc_base);

err_noirq:
    free_irq(IRQ_ADC, 1);

    return ret;
}

/*初始化ADC控制寄存器和ADC触摸屏控制寄存器*/
static void adc_initialize(void)
{
    /*计算结果为(二进制)：111111111000000，再根据数据手册得知
    此处是将AD转换预定标器值设为255、AD转换预定标器使能有效*/
    writel(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(0xFF), adc_base + S3C2410_ADCCON);

    /*对ADC开始延时寄存器进行设置，延时值为0xffff*/
    writel(0xffff, adc_base + S3C2410_ADCDLY);

    /*WAIT4INT宏计算结果为(二进制)：11010011，再根据数据手册得知
    此处是将ADC触摸屏控制寄存器设置成等待中断模式*/
    writel(WAIT4INT(0), adc_base + S3C2410_ADCTSC);
}

static void __exit ts_exit(void)
{
    /*屏蔽和释放中断*/
    disable_irq(IRQ_ADC);
    disable_irq(IRQ_TC);
    free_irq(IRQ_ADC, 1);
    free_irq(IRQ_TC, 1);

    /*释放虚拟地址映射空间*/
    iounmap(adc_base);

    /*屏蔽和销毁时钟*/
    if(adc_clk)
    {
        clk_disable(adc_clk);
        clk_put(adc_clk);
        adc_clk = NULL;
    }

    /*将触摸屏设备从输入子系统中注销*/
    input_unregister_device(ts_dev);
}

module_init(ts_init);
module_exit(ts_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Huang Gang");
MODULE_DESCRIPTION("My2440 Touch Screen Driver");

3、接下来要做的是，在两个中断服务程序中实现触摸屏状态和坐标的转换。先看代码，如下：

/*定义一个外部的信号量ADC_LOCK，因为ADC_LOCK在ADC驱动程序中已申明
这样就能保证ADC资源在ADC驱动和触摸屏驱动中进行互斥访问*/
extern struct semaphore ADC_LOCK;

/*做为一个标签，只有对触摸屏操作后才对X和Y坐标进行转换*/
static int OwnADC = 0;

/*用于记录转换后的X坐标值和Y坐标值*/
static long xp;
static long yp;

/*用于计数对触摸屏压下或抬起时模拟输入转换的次数*/
static int count;

/*定义一个AUTOPST宏，将ADC触摸屏控制寄存器设置成自动转换模式*/
#define AUTOPST    (S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | \
                S3C2410_ADCTSC_AUTO_PST | S3C2410_ADCTSC_XY_PST(0))


/*触摸屏中断服务程序，对触摸屏按下或提笔时触发执行*/
static irqreturn_t tc_irq(int irq, void *dev_id)
{
    /*用于记录这一次AD转换后的值*/
    unsigned long data0;
    unsigned long data1;

    /*用于记录触摸屏操作状态是按下还是抬起*/
    int updown;

    /*ADC资源可以获取，即上锁*/
    if (down_trylock(&ADC_LOCK) == 0)
    {
        /*标识对触摸屏进行了操作*/
        OwnADC = 1;

        /*读取这一次AD转换后的值，注意这次主要读的是状态*/
        data0 = readl(adc_base + S3C2410_ADCDAT0);
        data1 = readl(adc_base + S3C2410_ADCDAT1);

        /*记录这一次对触摸屏是压下还是抬起，该状态保存在数据寄存器的第15位，所以与上S3C2410_ADCDAT0_UPDOWN*/
        updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));

        /*判断触摸屏的操作状态*/
        if (updown)
        {
            /*如果是按下状态，则调用touch_timer_fire函数来启动ADC转换，该函数定义后面再讲*/
            touch_timer_fire(0);
        }
        else
        {
            /*如果是抬起状态，就结束了这一次的操作，所以就释放ADC资源的占有*/
            OwnADC = 0;
            up(&ADC_LOCK);
        }
    }

    return IRQ_HANDLED;
}

static void touch_timer_fire(unsigned long data)
{
    /*用于记录这一次AD转换后的值*/
      unsigned long data0;
      unsigned long data1;

    /*用于记录触摸屏操作状态是按下还是抬起*/
    int updown;

    /*读取这一次AD转换后的值，注意这次主要读的是状态*/
      data0 = readl(adc_base + S3C2410_ADCDAT0);
    data1 = readl(adc_base + S3C2410_ADCDAT1);

    /*记录这一次对触摸屏是压下还是抬起，该状态保存在数据寄存器的第15位，所以与上S3C2410_ADCDAT0_UPDOWN*/
     updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));

    /*判断触摸屏的操作状态*/
     if (updown)
    {
        /*如果状态是按下，并且ADC已经转换了就报告事件和数据*/
         if (count != 0)
        {
            long tmp;
                                                                                                 
            tmp = xp;
            xp = yp;
            yp = tmp;
                                                                                                 
            xp >>= 2;
            yp >>= 2;

#ifdef CONFIG_TOUCHSCREEN_MY2440_DEBUG
            /*触摸屏调试信息，编译内核时选上此项后，点击触摸屏会在终端上打印出坐标信息*/
            struct timeval tv;
            do_gettimeofday(&tv);
            printk(KERN_DEBUG "T: %06d, X: %03ld, Y: %03ld\n", (int)tv.tv_usec, xp, yp);
#endif

            /*报告X、Y的绝对坐标值*/
             input_report_abs(ts_dev, ABS_X, xp);
             input_report_abs(ts_dev, ABS_Y, yp);

            /*报告触摸屏的状态，1表明触摸屏被按下*/
            input_report_abs(ts_dev, ABS_PRESSURE, 1);

            /*报告按键事件，键值为1(代表触摸屏对应的按键被按下)*/
             input_report_key(ts_dev, BTN_TOUCH, 1);

            /*等待接收方受到数据后回复确认，用于同步*/
             input_sync(ts_dev);
         }

        /*如果状态是按下，并且ADC还没有开始转换就启动ADC进行转换*/
         xp = 0;
         yp = 0;
         count = 0;

        /*设置触摸屏的模式为自动转换模式*/
         writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, adc_base + S3C2410_ADCTSC);

        /*启动ADC转换*/
         writel(readl(adc_base + S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, adc_base + S3C2410_ADCCON);
     }
    else
    {
        /*否则是抬起状态*/
         count = 0;

        /*报告按键事件，键值为0(代表触摸屏对应的按键被释放)*/
         input_report_key(ts_dev, BTN_TOUCH, 0);

        /*报告触摸屏的状态，0表明触摸屏没被按下*/
         input_report_abs(ts_dev, ABS_PRESSURE, 0);

        /*等待接收方受到数据后回复确认，用于同步*/
         input_sync(ts_dev);

        /*将触摸屏重新设置为等待中断状态*/
         writel(WAIT4INT(0), adc_base + S3C2410_ADCTSC);

        /*如果触摸屏抬起，就意味着这一次的操作结束，所以就释放ADC资源的占有*/
        if (OwnADC)
        {
            OwnADC = 0;
            up(&ADC_LOCK);
        }
     }
}

/*定义并初始化了一个定时器touch_timer，定时器服务程序为touch_timer_fire*/
static struct timer_list touch_timer = TIMER_INITIALIZER(touch_timer_fire, 0, 0);

/*ADC中断服务程序，AD转换完成后触发执行*/
static irqreturn_t adc_irq(int irq, void *dev_id)
{
    /*用于记录这一次AD转换后的值*/
    unsigned long data0;
    unsigned long data1;

    if(OwnADC)
    {
        /*读取这一次AD转换后的值，注意这次主要读的是坐标*/
        data0 = readl(adc_base + S3C2410_ADCDAT0);
        data1 = readl(adc_base + S3C2410_ADCDAT1);

        /*记录这一次通过AD转换后的X坐标值和Y坐标值，根据数据手册可知，X和Y坐标转换数值
        分别保存在数据寄存器0和1的第0-9位，所以这里与上S3C2410_ADCDAT0_XPDATA_MASK就是取0-9位的值*/
        xp += data0 & S3C2410_ADCDAT0_XPDATA_MASK;
        yp += data1 & S3C2410_ADCDAT1_YPDATA_MASK;

        /*计数这一次AD转换的次数*/
        count++;

        if (count < (1<<2))
        {
            /*如果转换的次数小于4，则重新启动ADC转换*/
            writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, adc_base + S3C2410_ADCTSC);
            writel(readl(adc_base + S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, adc_base + S3C2410_ADCCON);
        }
        else
        {
            /*否则，启动1个时间滴答的定时器，这是就会去执行定时器服务程序上报事件和数据*/
            mod_timer(&touch_timer, jiffies + 1);
            writel(WAIT4INT(1), adc_base + S3C2410_ADCTSC);
        }
    }

    return IRQ_HANDLED;
}

我们从整体上描述转换这个的过程：
(1)如果触摸屏感觉到触摸，则触发触摸屏中断即进入tc_irq，获取ADC_LOCK后判断触摸屏状态为按下，则调用touch_timer_fire启动ADC转换；
(2)当ADC转换启动后，触发ADC中断即进入adc_irq，如果这一次转换的次数小于4，则重新启动ADC进行转换，如果4次完毕后，启动1个时间滴答的定时器，停止ADC转换，也就是说在这个时间滴答内，ADC转换是停止的；
(3)这里为什么要在1个时间滴答到来之前停止ADC的转换呢？这是为了防止屏幕抖动。
(4)如果1个时间滴答到来则进入定时器服务程序touch_timer_fire，判断触摸屏仍然处于按下状态则上报事件和转换的数据，并重启ADC转换，重复第(2)步；
(5)如果触摸抬起了，则上报释放事件，并将触摸屏重新设置为等待中断状态。

四、移植和测试触摸屏驱动程序

一、移植环境

• 主  机：VMWare--Fedora 9
• 开发板：Mini2440--64MB Nand
• 编译器：arm-linux-gcc-4.3.2

二、移植步骤

1. 准备驱动源码。因为linux-2.6.30.4内核中没有提供合适的ADC驱动和触摸屏驱动，所以这里就直接用友善提供的驱动

 

s3c24xx-adc.h

#ifndef _S3C2410_ADC_H_
#define _S3C2410_ADC_H_

#define ADC_WRITE(ch, prescale)    ((ch)<<16|(prescale))

#define ADC_WRITE_GETCH(data)    (((data)>>16)&0x7)
#define ADC_WRITE_GETPRE(data)    ((data)&0xff)

#endif /* _S3C2410_ADC_H_ */

mini2440_adc.c

#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/delay.h>
#include <linux/clk.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
#include <mach/regs-clock.h>
#include <plat/regs-timer.h>
    
#include <plat/regs-adc.h>
#include <mach/regs-gpio.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>

#include "s3c24xx-adc.h"

#undef DEBUG
//#define DEBUG

#ifdef DEBUG
#define DPRINTK(x...) {printk(__FUNCTION__"(%d): ",__LINE__);printk(##x);}
#else
#define DPRINTK(x...) (void)(0)
#endif

#define DEVICE_NAME    "adc"

static void __iomem *base_addr;

typedef struct {
    wait_queue_head_t wait;
    int channel;
    int prescale;
}ADC_DEV;

DECLARE_MUTEX(ADC_LOCK);
static int OwnADC = 0;

static ADC_DEV adcdev;
static volatile int ev_adc = 0;
static int adc_data;

static struct clk    *adc_clock;

#define ADCCON (*(volatile unsigned long *)(base_addr + S3C2410_ADCCON))    //ADC control

#define ADCTSC (*(volatile unsigned long *)(base_addr + S3C2410_ADCTSC))    //ADC touch screen control

#define ADCDLY (*(volatile unsigned long *)(base_addr + S3C2410_ADCDLY))    //ADC start or Interval Delay

#define ADCDAT0 (*(volatile unsigned long *)(base_addr + S3C2410_ADCDAT0))    //ADC conversion data 0

#define ADCDAT1 (*(volatile unsigned long *)(base_addr + S3C2410_ADCDAT1))    //ADC conversion data 1

#define ADCUPDN (*(volatile unsigned long *)(base_addr + 0x14))    //Stylus Up/Down interrupt status

#define PRESCALE_DIS (0 << 14)
#define PRESCALE_EN (1 << 14)
#define PRSCVL(x) ((x) << 6)
#define ADC_INPUT(x) ((x) << 3)
#define ADC_START (1 << 0)
#define ADC_ENDCVT (1 << 15)

#define START_ADC_AIN(ch, prescale) \
    do{ \
        ADCCON = PRESCALE_EN | PRSCVL(prescale) | ADC_INPUT((ch)) ; \
        ADCCON |= ADC_START; \
    }while(0)

static irqreturn_t adcdone_int_handler(int irq, void *dev_id)
{
    if (OwnADC) {
        adc_data = ADCDAT0 & 0x3ff;

        ev_adc = 1;
        wake_up_interruptible(&adcdev.wait);
    }

    return IRQ_HANDLED;
}

static ssize_t s3c2410_adc_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
{
    char str[20];
    int value;
    size_t len;
    if (down_trylock(&ADC_LOCK) == 0) {
        OwnADC = 1;
        START_ADC_AIN(adcdev.channel, adcdev.prescale);
        wait_event_interruptible(adcdev.wait, ev_adc);

        ev_adc = 0;

        DPRINTK("AIN[%d] = 0x%04x, %d\n", adcdev.channel, adc_data, ADCCON & 0x80 ? 1:0);

        value = adc_data;
        sprintf(str,"%5d", adc_data);
        copy_to_user(buffer, (char *)&adc_data, sizeof(adc_data));

        OwnADC = 0;
        up(&ADC_LOCK);
    } else {
        value = -1;
    }

    len = sprintf(str, "%d\n", value);
    if (count >= len) {
        int r = copy_to_user(buffer, str, len);
        return r ? r : len;
    } else {
        return -EINVAL;
    }
}

static int s3c2410_adc_open(struct inode *inode, struct file *filp)
{
    init_waitqueue_head(&(adcdev.wait));

    adcdev.channel=0;
    adcdev.prescale=0xff;

    DPRINTK( "adc opened\n");
    return 0;
}

static int s3c2410_adc_release(struct inode *inode, struct file *filp)
{
    DPRINTK( "adc closed\n");
    return 0;
}

static struct file_operations dev_fops = {
    owner:    THIS_MODULE,
    open:    s3c2410_adc_open,
    read:    s3c2410_adc_read,    
    release:    s3c2410_adc_release,
};

static struct miscdevice misc = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = DEVICE_NAME,
    .fops = &dev_fops,
};

static int __init dev_init(void)
{
    int ret;

    base_addr=ioremap(S3C2410_PA_ADC,0x20);
    if (base_addr == NULL) {
        printk(KERN_ERR "Failed to remap register block\n");
        return -ENOMEM;
    }

    adc_clock = clk_get(NULL, "adc");
    if (!adc_clock) {
        printk(KERN_ERR "failed to get adc clock source\n");
        return -ENOENT;
    }
    clk_enable(adc_clock);
    
    /* normal ADC */
    ADCTSC = 0;

    ret = request_irq(IRQ_ADC, adcdone_int_handler, IRQF_SHARED, DEVICE_NAME, &adcdev);
    if (ret) {
        iounmap(base_addr);
        return ret;
    }

    ret = misc_register(&misc);

    printk (DEVICE_NAME"\tinitialized\n");
    return ret;
}

static void __exit dev_exit(void)
{
    free_irq(IRQ_ADC, &adcdev);
    iounmap(base_addr);

    if (adc_clock) {
        clk_disable(adc_clock);
        clk_put(adc_clock);
        adc_clock = NULL;
    }

    misc_deregister(&misc);
}

EXPORT_SYMBOL(ADC_LOCK);
module_init(dev_init);
module_exit(dev_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("FriendlyARM Inc.");


s3c2410_ts.c

#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/delay.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <asm/io.h>
#include <asm/irq.h>

#include <plat/regs-adc.h>
#include <mach/regs-gpio.h>

/* For ts.dev.id.version */
#define S3C2410TSVERSION    0x0101

#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))

static char *s3c2410ts_name = "s3c2410 TouchScreen";

static    struct input_dev *dev;
static    long xp;
static    long yp;
static    int count;

extern struct semaphore ADC_LOCK;
static int OwnADC = 0;

static void __iomem *base_addr;

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 touch_timer_fire(unsigned long data)
{
      unsigned long data0;
      unsigned long data1;
    int updown;

      data0 = ioread32(base_addr+S3C2410_ADCDAT0);
      data1 = ioread32(base_addr+S3C2410_ADCDAT1);

     updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));

     if (updown) {
         if (count != 0) {
            long tmp;
                                                                                                 
            tmp = xp;
            xp = yp;
            yp = tmp;
                                                                                                 
            xp >>= 2;
            yp >>= 2;

#ifdef CONFIG_TOUCHSCREEN_MY2440_DEBUG
            struct timeval tv;
            do_gettimeofday(&tv);
            printk(KERN_DEBUG "T: %06d, X: %03ld, Y: %03ld\n", (int)tv.tv_usec, xp, yp);
#endif

             input_report_abs(dev, ABS_X, xp);
             input_report_abs(dev, ABS_Y, yp);

             input_report_key(dev, BTN_TOUCH, 1);
             input_report_abs(dev, ABS_PRESSURE, 1);
             input_sync(dev);
         }

         xp = 0;
         yp = 0;
         count = 0;

         iowrite32(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC);
         iowrite32(ioread32(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON);
     } else {
         count = 0;

         input_report_key(dev, BTN_TOUCH, 0);
         input_report_abs(dev, ABS_PRESSURE, 0);
         input_sync(dev);

         iowrite32(WAIT4INT(0), base_addr+S3C2410_ADCTSC);
        if (OwnADC) {
            OwnADC = 0;
            up(&ADC_LOCK);
        }
     }
}

static struct timer_list touch_timer =
        TIMER_INITIALIZER(touch_timer_fire, 0, 0);

static irqreturn_t stylus_updown(int irq, void *dev_id)
{
    unsigned long data0;
    unsigned long data1;
    int updown;

    if (down_trylock(&ADC_LOCK) == 0) {
        OwnADC = 1;
        data0 = ioread32(base_addr+S3C2410_ADCDAT0);
        data1 = ioread32(base_addr+S3C2410_ADCDAT1);

        updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));

        if (updown) {
            touch_timer_fire(0);
        } else {
            OwnADC = 0;
            up(&ADC_LOCK);
        }
    }

    return IRQ_HANDLED;
}

static irqreturn_t stylus_action(int irq, void *dev_id)
{
    unsigned long data0;
    unsigned long data1;

    if (OwnADC) {
        data0 = ioread32(base_addr+S3C2410_ADCDAT0);
        data1 = ioread32(base_addr+S3C2410_ADCDAT1);

        xp += data0 & S3C2410_ADCDAT0_XPDATA_MASK;
        yp += data1 & S3C2410_ADCDAT1_YPDATA_MASK;
        count++;

     if (count < (1<<2)) {
            iowrite32(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC);
            iowrite32(ioread32(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON);
        } else {
            mod_timer(&touch_timer, jiffies+1);
            iowrite32(WAIT4INT(1), base_addr+S3C2410_ADCTSC);
        }
    }

    return IRQ_HANDLED;
}

static struct clk    *adc_clock;

static int __init s3c2410ts_init(void)
{
    struct input_dev *input_dev;

    adc_clock = clk_get(NULL, "adc");
    if (!adc_clock) {
        printk(KERN_ERR "failed to get adc clock source\n");
        return -ENOENT;
    }
    clk_enable(adc_clock);

    base_addr=ioremap(S3C2410_PA_ADC,0x20);
    if (base_addr == NULL) {
        printk(KERN_ERR "Failed to remap register block\n");
        return -ENOMEM;
    }

    /* Configure GPIOs */
    s3c2410_ts_connect();

    iowrite32(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(0xFF),\
         base_addr+S3C2410_ADCCON);
    iowrite32(0xffff, base_addr+S3C2410_ADCDLY);
    iowrite32(WAIT4INT(0), base_addr+S3C2410_ADCTSC);

    /* Initialise input stuff */
    input_dev = input_allocate_device();

    if (!input_dev) {
        printk(KERN_ERR "Unable to allocate the input device !!\n");
        return -ENOMEM;
    }

    dev = input_dev;
    dev->evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS);
    dev->keybit[BITS_TO_LONGS(BTN_TOUCH)] = BIT(BTN_TOUCH);
    input_set_abs_params(dev, ABS_X, 0, 0x3FF, 0, 0);
    input_set_abs_params(dev, ABS_Y, 0, 0x3FF, 0, 0);
    input_set_abs_params(dev, ABS_PRESSURE, 0, 1, 0, 0);

    dev->name = s3c2410ts_name;
    dev->id.bustype = BUS_RS232;
    dev->id.vendor = 0xDEAD;
    dev->id.product = 0xBEEF;
    dev->id.version = S3C2410TSVERSION;

    /* Get irqs */
    if (request_irq(IRQ_ADC, stylus_action, IRQF_SHARED|IRQF_SAMPLE_RANDOM,
        "s3c2410_action", dev)) {
        printk(KERN_ERR "s3c2410_ts.c: Could not allocate ts IRQ_ADC !\n");
        iounmap(base_addr);
        return -EIO;
    }
    if (request_irq(IRQ_TC, stylus_updown, IRQF_SAMPLE_RANDOM,
            "s3c2410_action", dev)) {
        printk(KERN_ERR "s3c2410_ts.c: Could not allocate ts IRQ_TC !\n");
        iounmap(base_addr);
        return -EIO;
    }

    printk(KERN_INFO "%s successfully loaded\n", s3c2410ts_name);

    /* All went ok, so register to the input system */
    input_register_device(dev);

    return 0;
}

static void __exit s3c2410ts_exit(void)
{
    disable_irq(IRQ_ADC);
    disable_irq(IRQ_TC);
    free_irq(IRQ_TC,dev);
    free_irq(IRQ_ADC,dev);

    if (adc_clock) {
        clk_disable(adc_clock);
        clk_put(adc_clock);
        adc_clock = NULL;
    }

    input_unregister_device(dev);
    iounmap(base_addr);
}

module_init(s3c2410ts_init);
module_exit(s3c2410ts_exit);


2. 部署驱动源代码到内核中

#cp -f s3c24xx-adc.h mini2440_adc.c /linux-2.6.30.4/drivers/char/

#cp -f s3c2410_ts.c /linux-2.6.30.4/drivers/input/touchscreen/

3. 将驱动模块添加到内核配置文件中

 

#gedit linux-2.6.30.4/drivers/char/Kconfig  //添加如下内容

config MY2440_ADC
    bool "ADC device for my2440"
    default y

#gedit linux-2.6.30.4/drivers/char/Makefile  //添加如下内容

obj-$(CONFIG_MY2440_ADC)  += mini2440_adc.o

#gedit linux-2.6.30.4/drivers/input/touchscreen/Kconfig  //添加如下内容

config TOUCHSCREEN_MY2440
    tristate "MY2440 touchscreens input driver"
    default y
 
config TOUCHSCREEN_MY2440_DEBUG
    boolean "MY2440 touchscreens input driver debug messages"
    depends on TOUCHSCREEN_MY2440
    help
        Select this if you want debug messages

#gedit linux-2.6.30.4/drivers/input/touchscreen/Makefile  //添加如下内容

obj-$(CONFIG_TOUCHSCREEN_MY2440) += s3c2410_ts.o

4. 修改内核配置选项

 

Device Drivers --->
    Input device support --->
        (240) Horizontal screen resolution
        (320) Vertical screen resolution
        [*] Touchscreens --->
            <*> MY2440 touchscreens input driver (NEW)
            [*] MY2440 touchscreens input driver debug messages
    Character devices --->
        [*] ADC device for my2440 (NEW)

5. 编译内核并下载到开发板上，从启动信息可以看到触摸屏驱动加载成功

6. 创建触摸屏设备节点并测试。由启动信息得知触摸屏设备为输入类设备，如下图操作可以得知输入类设备的主设备号为13，又查看总线的具体输入设备可得知该设备的详细信息，根据这些信息我们建立好设备节点，设置内核调试级别为8，然后打开触摸屏设备，点击触摸屏，此时可以看到打印的坐标信息，即触摸屏可正常使用了